43var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(text, encoding: null, SourceHashAlgorithms.Default));

44_tree = SyntaxFactory.ParseSyntaxTree(_text);

940new[] { SyntaxFactory.ParseSyntaxTree(source) },

9475var conditionalAccessNode = SyntaxFactory.FindConditionalAccessNodeForBinding(binding);

207var tree = SyntaxFactory.ParseSyntaxTree(

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

288expression = SyntaxFactory.GetStandaloneExpression(expression); 306var crefWrapper = SyntaxFactory.QualifiedCref(qualified.Left, SyntaxFactory.NameMemberCref(qualified.Right)); 312(CrefSyntax)SyntaxFactory.TypeCref(typeSyntax) : 313SyntaxFactory.NameMemberCref(typeSyntax);

161var expression = SyntaxFactory.GetStandaloneExpression(type); 192expression = SyntaxFactory.GetStandaloneExpression(expression); 2192var tmp = SyntaxFactory.GetStandaloneNode(node); 2298bindableParent = SyntaxFactory.GetStandaloneExpression((ArrayTypeSyntax)bindableParent);

220var loadedTree = SyntaxFactory.ParseSyntaxTree(

203node = SyntaxFactory.GetStandaloneNode(node); 304node = SyntaxFactory.GetStandaloneNode(node); 396node = SyntaxFactory.GetStandaloneNode(node); 405node = SyntaxFactory.GetStandaloneNode(node); 414node = SyntaxFactory.GetStandaloneNode(node);

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

275return SyntaxFactory.TokenList(items);

235var identifierName = SyntaxFactory.IdentifierName(symbol.Name); 274var token = SyntaxFactory.ParseToken(nameWithoutAttributeSuffix);

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

127return SyntaxFactory.Trivia(newStructure);

128return 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(

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

243if (!SyntaxFactory.AreEquivalent(sourceIdentifier, selectorIdentifier)) 366return oldTokens.SequenceEqual(newTokens, SyntaxFactory.AreEquivalent);

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

39return SyntaxFactory.MethodDeclaration(

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

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));

128return SyntaxFactory.TriviaList(sequence);

2092return SyntaxFactory.GetStandaloneNode(expression) as ExpressionSyntax ?? expression; 2275return SyntaxFactory.BinaryExpression(expression.Kind(), max.Expression, max.OperatorToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2283return SyntaxFactory.QualifiedName(qn.Left, qn.DotToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2291return SyntaxFactory.AliasQualifiedName(an.Alias, an.ColonColonToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2417return SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), value, SyntaxFactory.Token(SyntaxKind.ColonToken)); 2423return SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 2446return SyntaxFactory.PropertyDeclaration( 2467return SyntaxFactory.ConversionOperatorDeclaration( 2489return SyntaxFactory.ConversionOperatorDeclaration( 2511return SyntaxFactory.ConversionOperatorDeclaration( 2535return SyntaxFactory.ConversionOperatorDeclaration( 2560return SyntaxFactory.OperatorDeclaration( 2584return SyntaxFactory.OperatorDeclaration( 2607return SyntaxFactory.OperatorDeclaration( 2631return SyntaxFactory.OperatorDeclaration( 2676=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body, expressionBody: null); 2678=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body, expressionBody: null, semicolonToken); 2680=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body: null, expressionBody); 2682=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body: null, expressionBody, semicolonToken); 2712var openParen = needsParens ? SyntaxFactory.Token(SyntaxKind.OpenParenToken) : default; 2713var closeParen = needsParens ? SyntaxFactory.Token(SyntaxKind.CloseParenToken) : default; 2714return SyntaxFactory.SwitchStatement( 2716SyntaxFactory.Token(SyntaxKind.SwitchKeyword), 2720SyntaxFactory.Token(SyntaxKind.OpenBraceToken), 2722SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 2728return SyntaxFactory.SwitchStatement(expression, default(SyntaxList<SwitchSectionSyntax>)); 2759? AnonymousMethodExpression(default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), parameterList, block, null) 2826return SyntaxFactory.OperatorMemberCref( 2836return SyntaxFactory.ConversionOperatorMemberCref( 2847return SyntaxFactory.ClassDeclaration( 2856return SyntaxFactory.ClassDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2861=> SyntaxFactory.ClassDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2865=> SyntaxFactory.ClassDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2869=> 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); 2874return SyntaxFactory.StructDeclaration( 2883return SyntaxFactory.StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2888=> SyntaxFactory.StructDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2892=> SyntaxFactory.StructDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2896=> 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); 2906=> SyntaxFactory.InterfaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, typeParameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2910=> SyntaxFactory.InterfaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2914=> 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); 2918=> SyntaxFactory.EnumDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, baseList, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2922=> SyntaxFactory.EnumDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, null, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2926=> 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)); 468AddResidualTrivia(SyntaxFactory.TriviaList(directive.ParentTrivia), requiresNewLine: true);

41_eolTrivia = useElasticTrivia ? SyntaxFactory.ElasticEndOfLine(eolWhitespace) : SyntaxFactory.EndOfLine(eolWhitespace); 166_indentations.Add(_useElasticTrivia ? SyntaxFactory.ElasticWhitespace(text) : SyntaxFactory.Whitespace(text)); 1121return SyntaxFactory.TriviaList(currentTriviaList.First()); 1125return SyntaxFactory.TriviaList(currentTriviaList); 1134private static readonly SyntaxTrivia s_trimmedDocCommentExterior = SyntaxFactory.DocumentationCommentExterior("///"); 1138return _useElasticTrivia ? SyntaxFactory.ElasticSpace : SyntaxFactory.Space;

91SyntaxFactory.Token(GetTypeDeclarationKeywordKind(kind)), 96SyntaxFactory.Token(SyntaxKind.OpenBraceToken), 98SyntaxFactory.Token(SyntaxKind.CloseBraceToken), 104return SyntaxFactory.TypeDeclaration(kind, SyntaxFactory.Identifier(identifier)); 124return SyntaxFactory.ClassDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 126return SyntaxFactory.StructDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 128return SyntaxFactory.InterfaceDeclaration(attributes, modifiers, keyword, identifier, typeParameterList, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 130return SyntaxFactory.RecordDeclaration(SyntaxKind.RecordDeclaration, attributes, modifiers, keyword, classOrStructKeyword: default, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken); 132return SyntaxFactory.RecordDeclaration(SyntaxKind.RecordStructDeclaration, attributes, modifiers, keyword, classOrStructKeyword: SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList: null, baseList, constraintClauses, openBraceToken, members, closeBraceToken, semicolonToken);

51var dummyStatement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( 53SyntaxFactory.IdentifierName("_"), 54SyntaxFactory.IsPatternExpression( 56SyntaxFactory.ConstantPattern(SyntaxFactory.ParenthesizedExpression(binaryExpression.Right.WithAdditionalAnnotations(s_annotation))) 164if (!SyntaxFactory.AreEquivalent(target.Syntax, compareTarget.Syntax))

19return SyntaxFactory.TokenList(SyntaxFactory.Token(argument.RefKindKeyword.Kind()));

27block = SyntaxFactory.Block(statement);

64arrowExpression = SyntaxFactory.ArrowExpressionClause(expression); 139expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

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

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

273SimpleLambdaExpressionSyntax simpleLambda => SyntaxFactory.SingletonSeparatedList(simpleLambda.Parameter),

45=> SyntaxFactory.ElasticMarker; 48=> SyntaxFactory.ElasticCarriageReturnLineFeed; 77=> SyntaxFactory.ParseToken(text); 80=> SyntaxFactory.ParseLeadingTrivia(text); 172=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 464var token = SyntaxFactory.ParseToken(identifier); 470var token = SyntaxFactory.ParseToken(identifier); 1342=> SyntaxFactory.AreEquivalent(token1, token2); 1345=> SyntaxFactory.AreEquivalent(node1, node2);

50=> SyntaxFactory.Whitespace(text); 56_newLine = SyntaxFactory.EndOfLine(Context.Options.NewLine); 224var multilineCommentTrivia = SyntaxFactory.ParseLeadingTrivia(multiLineComment); 338var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken)); 372var formattedTrivia = SyntaxFactory.Trivia((StructuredTriviaSyntax)result.GetFormattedRoot(cancellationToken));

57var parsedNewTrivia = SyntaxFactory.DocumentationCommentExterior(newTriviaText);

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

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

387if (parent.Target.Identifier == SyntaxFactory.Token(SyntaxKind.AssemblyKeyword) || 388parent.Target.Identifier == SyntaxFactory.Token(SyntaxKind.ModuleKeyword))

884var semicolonToken = semicolonTokenOpt ?? SyntaxFactory.Token(SyntaxKind.SemicolonToken); 894return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 900return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 903.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 907return SyntaxFactory.ReturnStatement(expression) 913return SyntaxFactory.ExpressionStatement(expression)

151if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 156SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

20return SyntaxFactory.List<AttributeListSyntax>();

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

19return SyntaxFactory.List(result); 23=> SyntaxFactory.List(sequence);

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

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

91var trailingTrivia = SyntaxFactory.ParseTrailingTrivia(text); 94var leadingTrivia = SyntaxFactory.ParseLeadingTrivia(text[width..]); 147return SyntaxFactory.ParseLeadingTrivia(text);

160arrowExpression = SyntaxFactory.ArrowExpressionClause(getAccessor.ExpressionBody.Expression); 180SyntaxFactory.Token(SyntaxKind.SemicolonToken), false, block: out _) != true) 296var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration); 302return WithAccessorList(declaration, SyntaxFactory.AccessorList( 303SyntaxFactory.SingletonList(accessor)));

26using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

24=> oldArgumentList.WithArguments(SyntaxFactory.SeparatedList(newArguments));

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

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

24=> oldArgumentList.WithArguments(SyntaxFactory.SeparatedList(newArguments));

33: SyntaxFactory.SingletonList(SyntaxFactory.AttributeList( 34target.HasValue ? SyntaxFactory.AttributeTargetSpecifier(target.Value) : null, 35SyntaxFactory.SeparatedList(attributeNodes))); 45: SyntaxFactory.List<AttributeListSyntax>(attributeDeclarations); 55: SyntaxFactory.AttributeList( 57? SyntaxFactory.AttributeTargetSpecifier(target.Value) 59SyntaxFactory.SingletonSeparatedList(attributeSyntax)); 81? SyntaxFactory.Attribute(nameSyntax, attributeArguments) 92SyntaxFactory.AttributeArgument(ExpressionGenerator.GenerateExpression(generator, c)))); 95SyntaxFactory.AttributeArgument( 96SyntaxFactory.NameEquals(SyntaxFactory.IdentifierName(kvp.Key)), null, 99return SyntaxFactory.AttributeArgumentList(SyntaxFactory.SeparatedList(arguments));

55var declaration = SyntaxFactory.ConstructorDeclaration( 62semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default); 100: SyntaxFactory.ConstructorInitializer(kind).WithArgumentList(GenerateArgumentList(arguments)); 104=> SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments.Select(ArgumentGenerator.GenerateArgument))); 113return SyntaxFactory.Block(statements); 122tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 131tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));

82.WithTrailingTrivia(SyntaxFactory.Space); 101replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

56? SyntaxFactory.Token(SyntaxKind.ImplicitKeyword) 57: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword); 60? SyntaxFactory.Token(SyntaxKind.CheckedKeyword) 63var declaration = SyntaxFactory.ConversionOperatorDeclaration( 68operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), 74semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()); 104return SyntaxFactory.TokenList( 105SyntaxFactory.Token(SyntaxKind.StaticKeyword), 106SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 109return SyntaxFactory.TokenList( 110SyntaxFactory.Token(SyntaxKind.PublicKeyword), 111SyntaxFactory.Token(SyntaxKind.StaticKeyword));

190var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken) 199var fileScopedNamespace = SyntaxFactory.FileScopedNamespaceDeclaration( 248var namespaceDeclaration = SyntaxFactory.NamespaceDeclaration( 253SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithTrailingTrivia(fileScopedNamespace.SemicolonToken.TrailingTrivia), 257SyntaxFactory.Token(SyntaxKind.CloseBraceToken),

17using static SyntaxFactory;

150SyntaxFactory.EqualsValueClause(SyntaxFactory.IdentifierName(property.Identifier.WithoutTrivia()))) 151.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); 212.WithInitializer(SyntaxFactory.ConstructorInitializer( 214SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( 215expressions.Select(SyntaxFactory.Argument))))); 278? SyntaxFactory.Identifier(result.Symbol.Name) 281return SyntaxFactory.Parameter( 291var recordKeyword = SyntaxFactory.Token(SyntaxKind.RecordKeyword); 339SyntaxFactory.Argument(SyntaxFactory.IdentifierName(prop.Name))); 342SyntaxFactory.PrimaryConstructorBaseType(baseRecord.Type.WithoutTrailingTrivia(), 343SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(inheritedPositionalParams)) 375? SyntaxFactory.Token(SyntaxKind.SemicolonToken) 381? SyntaxFactory.Token(SyntaxKind.OpenBraceToken) 384? SyntaxFactory.Token(SyntaxKind.CloseBraceToken) 395return SyntaxFactory.RecordDeclaration( 404: typeDeclaration.Keyword.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 406typeDeclaration.Identifier.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 407typeDeclaration.TypeParameterList?.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 408SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(propertiesToAddAsParams)) 434return SyntaxFactory.List<AttributeListSyntax>(); 437return SyntaxFactory.List(result.Declaration.AttributeLists.SelectAsArray(attributeList => 443.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.PropertyKeyword))) 536return SyntaxFactory.ObjectCreationExpression( 539SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(updatedExpressions 540.Select(expression => SyntaxFactory.Argument(expression.WithoutTrivia())))), 599return SyntaxFactory.TriviaList(classTrivia.Concat(propertyNonDocComments).Select(trivia => trivia.AsElastic())); 629newClassDocComment = SyntaxFactory.DocumentationCommentTrivia( 634SyntaxFactory.List(propertyParamComments.Skip(1) 635.Prepend(SyntaxFactory.XmlText(SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false) 636.WithLeadingTrivia(SyntaxFactory.DocumentationCommentExterior("/**")) 638.Append(SyntaxFactory.XmlText(SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false)))), 639SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken) 640.WithTrailingTrivia(SyntaxFactory.DocumentationCommentExterior("*/"), SyntaxFactory.ElasticCarriageReturnLineFeed)); 646newClassDocComment = SyntaxFactory.DocumentationCommentTrivia( 648SyntaxFactory.List(propertyParamComments.Skip(1) 649.Prepend(SyntaxFactory.XmlText(SyntaxFactory.XmlTextLiteral(" ").WithLeadingTrivia(exteriorTrivia))))) 650.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed); 658return SyntaxFactory.TriviaList(classTrivia 661.Append(SyntaxFactory.Trivia(newClassDocComment)) 667return SyntaxFactory.TriviaList(classTrivia 668.Replace(classDocComment.Value, SyntaxFactory.Trivia(newClassDocComment)) 740yield return SyntaxFactory.XmlText( 741SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false), 742SyntaxFactory.XmlTextLiteral(" ").WithLeadingTrivia(exteriorTrivia)); 747yield return SyntaxFactory.XmlParamElement(result.Symbol.Name, SyntaxFactory.XmlEmptyElement( 748SyntaxFactory.XmlName(DocumentationCommentXmlNames.InheritdocElementName))); 797return text.WithTextTokens(SyntaxFactory.TokenList(tokens)); 804yield return SyntaxFactory.XmlParamElement(result.Declaration.Identifier.ValueText, paramContent.AsArray());

410return SyntaxFactory.LiteralExpression(

42SyntaxFactory.NameEquals( 43SyntaxFactory.IdentifierName(name)));

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

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

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

122var newCloseParen = SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTriviaFrom(parenthesizedExpression.CloseParenToken);

78var yieldStatement = SyntaxFactory.YieldStatement(

23using static SyntaxFactory;

105var declarationPattern = SyntaxFactory.DeclarationPattern( 106GetPatternType().WithoutTrivia().WithTrailingTrivia(SyntaxFactory.ElasticMarker), 107SyntaxFactory.SingleVariableDesignation(newIdentifier)); 166var isPatternExpression = SyntaxFactory.IsPatternExpression(asExpression.Left, declarationPattern); 176SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), isPatternExpression.Pattern)); 180return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, isPatternExpression.Parenthesize());

47tokens.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); 50tokens.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)); 53tokens.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); 56tokens.Add(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); 57tokens.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)); 60tokens.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword)); 63tokens.Add(SyntaxFactory.Token(SyntaxKind.ProtectedKeyword)); 64tokens.Add(SyntaxFactory.Token(SyntaxKind.InternalKeyword)); 97return SyntaxFactory.SyntaxTrivia(SyntaxKind.MultiLineCommentTrivia, text + MultiLineCommentTerminator); 118var updatedTokens = SyntaxFactory.TokenList(tokens.Select(ReplaceUnterminatedConstruct)); 121return SyntaxFactory.Trivia(updatedSyntax); 132return SyntaxFactory.Literal(token.LeadingTrivia, tokenText, token.ValueText, token.TrailingTrivia); 141return SyntaxFactory.Literal(token.LeadingTrivia, tokenText, token.ValueText, token.TrailingTrivia); 185return declarationList.Insert(index, declaration.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed)); 220return SyntaxFactory.ExplicitInterfaceSpecifier(name); 256? node.WithPrependedLeadingTrivia(SyntaxFactory.ParseLeadingTrivia(comment)) 257.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker) 282variableDeclarationNode.WithVariables(SyntaxFactory.SingletonSeparatedList(variableDeclaratorNode)))) as T;

464var newAttributes = SyntaxFactory.SeparatedList(attributes.Where(a => a != attributeToRemove)); 512var wrappedStatements = StatementGenerator.GenerateStatements(statements).Select(SyntaxFactory.GlobalStatement).ToArray(); 520var block = statement as BlockSyntax ?? SyntaxFactory.Block(statement); 616var semicolonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken); 619var block = SyntaxFactory.Block(statement);

102SyntaxFactory.ParseTypeName("Task")

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

26using static SyntaxFactory;

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

217(t, g) => t.WithTrailingTrivia(SyntaxFactory.ElasticSpace).WithoutAnnotations(Formatter.Annotation)); 245declarationExpression = SyntaxFactory.DeclarationExpression(explicitType, declarationExpression.Designation); 263? SyntaxFactory.IdentifierName("var") 283var designation = SyntaxFactory.SingleVariableDesignation(identifier.Identifier); 310newType = newType.WithAppendedTrailingTrivia(SyntaxFactory.ElasticSpace); 313return SyntaxFactory.DeclarationExpression(newType, designation); 330yield return SyntaxFactory.Space;

69var updatedCondition = SyntaxFactory.IsPatternExpression( 70isExpression.Left, SyntaxFactory.DeclarationPattern( 72SyntaxFactory.SingleVariableDesignation( 77.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

29private static readonly SyntaxToken s_asyncToken = SyntaxFactory.Token(SyntaxKind.AsyncKeyword); 158var result = SyntaxFactory.GenericName( 159SyntaxFactory.Identifier(type), 160SyntaxFactory.TypeArgumentList(SyntaxFactory.SingletonSeparatedList(typeArgumentFrom.GetTypeArguments()[0].GenerateTypeSyntax()))); 185var result = SyntaxFactory.TokenList(s_asyncToken.WithLeadingTrivia(newReturnType.GetLeadingTrivia()));

66newReturnType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)).WithTriviaFrom(returnTypeSyntax);

75.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(forEach.GetLeadingTrivia())); 80.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(forEachDeconstruction.GetLeadingTrivia())); 85.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(usingStatement.GetLeadingTrivia())); 90.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(localDeclaration.GetLeadingTrivia()));

16using static SyntaxFactory;

37var semicolonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken); 40var block = SyntaxFactory.Block(statement);

46=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

61return SyntaxFactory.BinaryExpression( 74SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

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

40=> SyntaxFactory.Block(statements); 65var objectCreationNode = SyntaxFactory.ObjectCreationExpression( 77? SyntaxFactory.DiscardDesignation().WithTriviaFrom(node) 78: SyntaxFactory.SingleVariableDesignation(newName).WithTriviaFrom(node); 86? SyntaxFactory.DiscardPattern().WithTriviaFrom(node) 87: SyntaxFactory.DiscardDesignation(); 105return SyntaxFactory.TypePattern(declarationPattern.Type).WithTrailingTrivia(trailingTrivia); 115var objectCreationNode = SyntaxFactory.ObjectCreationExpression( 183SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, leftOfAssignment, rightOfAssignment)); 195return SyntaxFactory.BinaryExpression(mappedBinaryExpressionKind, leftOfAssignment, rightOfAssignment);

71var discardToken = SyntaxFactory.Identifier( 77var replacementNode = SyntaxFactory.IdentifierName(discardToken); 98var replacementNode = SyntaxFactory.BinaryExpression( 214_editor.ReplaceNode(_localDeclarationStatement, SyntaxFactory.Block(_statementsBuilder)); 227var statement = SyntaxFactory.LocalDeclarationStatement( 228SyntaxFactory.VariableDeclaration(_localDeclarationStatement.Declaration.Type, _currentNonDiscardVariables)) 244SyntaxFactory.ExpressionStatement( 245SyntaxFactory.AssignmentExpression( 247left: SyntaxFactory.IdentifierName(variable.Identifier),

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

23using static SyntaxFactory;

98var closeBrace = SyntaxFactory.Token(SyntaxKind.CloseBraceToken)

34=> SyntaxFactory.EndOfLine(text); 38return SyntaxFactory.LocalDeclarationStatement( 39isConst ? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword)) : default, 47=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 51return SyntaxFactory.VariableDeclaration( 52type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 53SyntaxFactory.SingletonSeparatedList( 54SyntaxFactory.VariableDeclarator( 56expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression)))); 60=> SyntaxFactory.Identifier(identifier); 63=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 66=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 69=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 83=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 92=> SyntaxFactory.InterpolatedStringExpression(startToken, SyntaxFactory.List(content.Cast<InterpolatedStringContentSyntax>()), endToken); 95=> SyntaxFactory.InterpolatedStringText(textToken); 98=> SyntaxFactory.Token( 99SyntaxFactory.TriviaList(), 102SyntaxFactory.TriviaList()); 105=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 108=> SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Token(SyntaxKind.CommaToken), (ExpressionSyntax)alignment); 111=> SyntaxFactory.InterpolationFormatClause( 112SyntaxFactory.Token(SyntaxKind.ColonToken), 113SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 116=> SyntaxFactory.TypeParameterList( 117SyntaxFactory.SeparatedList( 118typeParameterNames.Select(n => SyntaxFactory.TypeParameter(n)))); 124RefKind.Out => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.OutKeyword)), 125RefKind.Ref => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.RefKeyword)), 129RefKind.In when !forFunctionPointerReturnParameter => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InKeyword)), 130RefKind.RefReadOnly when forFunctionPointerReturnParameter => SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), 154=> SyntaxFactory.IsPatternExpression( 156isKeyword == default ? SyntaxFactory.Token(SyntaxKind.IsKeyword) : isKeyword, 160=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 163=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 166=> SyntaxFactory.DeclarationPattern( 168SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 171=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.LessThanToken), (ExpressionSyntax)expression); 174=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.LessThanEqualsToken), (ExpressionSyntax)expression); 177=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.GreaterThanToken), (ExpressionSyntax)expression); 180=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.GreaterThanEqualsToken), (ExpressionSyntax)expression); 183=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), (PatternSyntax)Parenthesize(pattern)); 186=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 192=> SyntaxFactory.TypePattern((TypeSyntax)type); 195=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)Parenthesize(pattern));

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

78var commaToken = SyntaxFactory.Token(SyntaxKind.CommaToken) 91return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens); 112SyntaxFactory.ImplicitElementAccess(elementAccess.ArgumentList)); 127? SyntaxFactory.ParenthesizedExpression(expression) 131return SyntaxFactory.InitializerExpression( 133SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithoutTrivia(), 134SyntaxFactory.SeparatedList( 137SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithoutTrivia());

28=> SyntaxFactory.Token(kind); 33return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right); 47=> SyntaxFactory.PostfixUnaryExpression(kind, operand); 50=> SyntaxFactory.PrefixUnaryExpression(kind, operand);

64var newAssignment = SyntaxFactory.AssignmentExpression( 67SyntaxFactory.Token(SyntaxKind.QuestionQuestionEqualsToken).WithTriviaFrom(assignment.OperatorToken), 110var compoundOperator = SyntaxFactory.Token(SyntaxKind.QuestionQuestionEqualsToken); 111var finalAssignment = SyntaxFactory.AssignmentExpression(

40=> variable.WithInitializer(SyntaxFactory.EqualsValueClause(value)); 55return block.WithStatements(SyntaxFactory.SingletonList(statement))

41return block.WithStatements(SyntaxFactory.SingletonList(statement))

17return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

124return SyntaxFactory.ForEachVariableStatement( 142return SyntaxFactory.ExpressionStatement( 143SyntaxFactory.AssignmentExpression( 163=> SyntaxFactory.DeclarationExpression( 164typeNode, SyntaxFactory.ParenthesizedVariableDesignation( 165SyntaxFactory.SeparatedList<VariableDesignationSyntax>(tupleType.TupleElements.Select( 166e => SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(e.Name.EscapeIdentifier())))))); 169=> SyntaxFactory.TupleExpression( 171SyntaxFactory.SeparatedList<ArgumentSyntax>(new SyntaxNodeOrTokenList(typeNode.Elements.GetWithSeparators().Select(ConvertTupleTypeElementComponent))), 185return SyntaxFactory.Argument( 186SyntaxFactory.DeclarationExpression( 188SyntaxFactory.SingleVariableDesignation(node.Identifier)));

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

62return SyntaxFactory.ImplicitObjectCreationExpression( 64currentObjectCreation.ArgumentList ?? SyntaxFactory.ArgumentList(),

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

23using static SyntaxFactory;

16using static SyntaxFactory;

34private static readonly TypeSyntax s_objectType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)); 215modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 235? SyntaxFactory.ArrowExpressionClause(((LambdaExpressionSyntax)anonymousFunction).ArrowToken, expression) 242return SyntaxFactory.LocalFunctionStatement( 255: SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(delegateMethod.Parameters.Select(parameter => 256PromoteParameter(generator, SyntaxFactory.Parameter(parameter.Name.ToIdentifierToken()), parameter)))); 282return SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(simpleLambda.Parameter)); 313return argumentNode.WithNameColon(argumentNode.NameColon.WithName(SyntaxFactory.IdentifierName(newParameter.Identifier))); 324=> SyntaxFactory.EqualsValueClause(ExpressionGenerator.GenerateExpression(generator, parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));

20using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

50var newStatementList = SyntaxFactory.SingletonList(newInnerStatement); 63=> SyntaxFactory.ElementBindingExpression(argumentList);

73var commaToken = SyntaxFactory.Token(SyntaxKind.CommaToken) 86return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens);

27using static SyntaxFactory;

29using static SyntaxFactory;

24using static SyntaxFactory;

49var declaration = SyntaxFactory.DestructorDeclaration( 52tildeToken: SyntaxFactory.Token(SyntaxKind.TildeToken), 54parameterList: SyntaxFactory.ParameterList(), 56semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default); 69return SyntaxFactory.Block(statements);

55var endOfLineTrivia = SyntaxFactory.ElasticEndOfLine(options.NewLine); 98AddLeadingTrivia(blockSyntax.CloseBraceToken, SyntaxFactory.ElasticMarker)); 121AddLeadingTrivia(currentBlock.OpenBraceToken, SyntaxFactory.ElasticMarker)); 125AddLeadingTrivia(currentBlock.CloseBraceToken, SyntaxFactory.ElasticMarker));

36members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); 43members.Add(SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(trailingTrivia)); 48.WithMembers(SyntaxFactory.SeparatedList<EnumMemberDeclarationSyntax>(members)); 64var member = SyntaxFactory.EnumMemberDeclaration(enumMember.Name.ToIdentifierToken()) 65.WithEqualsValue(value == null ? null : SyntaxFactory.EqualsValueClause(value: value)); 130return SyntaxFactory.BinaryExpression( 132SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(numericLiteral.Token.Text, 1)), 133SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(shiftValue.ToString(), shiftValue))); 145return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, 146SyntaxFactory.Literal(numericText[..2] + value.ToString("X"), value)); 150return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, 151SyntaxFactory.Literal(numericText[..2] + Convert.ToString(value, 2), value));

116SyntaxFactory.EventFieldDeclaration( 119SyntaxFactory.VariableDeclaration( 121SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(@event.Name.ToIdentifierToken())))))); 129return AddFormatterAndCodeGeneratorAnnotationsTo(SyntaxFactory.EventDeclaration( 147return SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()); 168return AddAnnotationsTo(accessor, SyntaxFactory.AccessorDeclaration(kind) 170.WithSemicolonToken(hasBody ? default : SyntaxFactory.Token(SyntaxKind.SemicolonToken))); 175return SyntaxFactory.Block( 199tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 208tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 212tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 220tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 228tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 231tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 234tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); 239tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));

35? SyntaxFactory.TypeOfExpression(((ITypeSymbol)typedConstant.Value).GenerateTypeSyntax()) 41: SyntaxFactory.ImplicitArrayCreationExpression( 42SyntaxFactory.InitializerExpression(SyntaxKind.ArrayInitializerExpression, 43SyntaxFactory.SeparatedList(typedConstant.Values.Select(v => GenerateExpression(generator, v))))); 51=> SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); 82sbyte val => GenerateLiteralExpression(type, val, LiteralSpecialValues.SByteSpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (sbyte)-x, "128"), 83short val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int16SpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v), x => x < 0, x => (short)-x, "32768"), 84int val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int32SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "2147483648"), 85long val => GenerateLiteralExpression(type, val, LiteralSpecialValues.Int64SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, "9223372036854775808"), 86byte val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.ByteSpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, v)), 87ushort val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt16SpecialValues, formatString: null, canUseFieldReference, (s, v) => SyntaxFactory.Literal(s, (uint)v)), 88uint val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt32SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal), 89ulong val => GenerateNonNegativeLiteralExpression(type, val, LiteralSpecialValues.UInt64SpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal), 92decimal val => GenerateLiteralExpression(type, val, LiteralSpecialValues.DecimalSpecialValues, formatString: null, canUseFieldReference, SyntaxFactory.Literal, x => x < 0, x => -x, integerMinValueString: null), 100return SyntaxFactory.LiteralExpression(val 108return SyntaxFactory.LiteralExpression( 109SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(valueString, val)); 115return SyntaxFactory.LiteralExpression( 116SyntaxKind.CharacterLiteralExpression, SyntaxFactory.Literal(literal, val)); 179return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 185return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 191return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 192SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, GenerateDoubleLiteralExpression(null, 1.0, false)), 199SyntaxFactory.Literal, x => x < 0, x => -x, integerMinValueString: null); 208return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 214return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 220return SyntaxFactory.BinaryExpression(SyntaxKind.DivideExpression, 221SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, GenerateSingleLiteralExpression(null, 1.0F, false)), 228SyntaxFactory.Literal, x => x < 0, x => -x, null); 271var literal = SyntaxFactory.LiteralExpression( 275? SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, literal) 292var result = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, memberAccess, SyntaxFactory.IdentifierName(constant.Value)); 302ExpressionSyntax result = SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)); 305var name = SyntaxFactory.IdentifierName(names[i]); 308result = SyntaxFactory.AliasQualifiedName((IdentifierNameSyntax)result, name); 312result = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, result, name);

58? SyntaxFactory.ParenthesizedExpression(withoutTrivia) 59: SyntaxFactory.ParenthesizedExpression( 60SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.OpenParenToken, SyntaxTriviaList.Empty), 62SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.CloseParenToken, SyntaxTriviaList.Empty)); 72? SyntaxFactory.ParenthesizedPattern(withoutTrivia) 73: SyntaxFactory.ParenthesizedPattern( 74SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.OpenParenToken, SyntaxTriviaList.Empty), 76SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.CloseParenToken, SyntaxTriviaList.Empty)); 89var castExpression = SyntaxFactory.CastExpression(

94? SyntaxFactory.EqualsValueClause(initializerNode) 97var fieldDeclaration = SyntaxFactory.FieldDeclaration( 100SyntaxFactory.VariableDeclaration( 102SyntaxFactory.SingletonSeparatedList( 103AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer))))); 114return SyntaxFactory.EqualsValueClause(ExpressionGenerator.GenerateExpression(generator, field.Type, field.ConstantValue, canUseFieldReference)); 127tokens.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword)); 133tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 138tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 143tokens.Add(SyntaxFactory.Token(SyntaxKind.RequiredKeyword)); 149tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));

18=> SyntaxFactory.PrefixUnaryExpression(

51var newModifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.NewKeyword));

96: (invocationExpression.Expression, SyntaxFactory.IdentifierName(nameof(Action.Invoke))); 99SyntaxFactory.ConditionalAccessExpression( 101SyntaxFactory.InvocationExpression( 102SyntaxFactory.MemberBindingExpression(invokeName), invocationExpression.ArgumentList))); 108newStatement = block.WithStatements(SyntaxFactory.SingletonList(newStatement)); 143: SyntaxFactory.IdentifierName(nameof(Action.Invoke)); 146SyntaxFactory.ConditionalAccessExpression( 148SyntaxFactory.InvocationExpression( 149SyntaxFactory.MemberBindingExpression(invokeName), invocationExpression.ArgumentList)));

42constraints.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint)); 46constraints.Add(SyntaxFactory.TypeConstraint(SyntaxFactory.IdentifierName("unmanaged"))); 50constraints.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint)); 54constraints.Add(SyntaxFactory.TypeConstraint(SyntaxFactory.IdentifierName("notnull"))); 66constraints.Add(SyntaxFactory.TypeConstraint(type.GenerateTypeSyntax())); 72constraints.Add(SyntaxFactory.ConstructorConstraint()); 80clauses.Add(SyntaxFactory.TypeParameterConstraintClause( 82SyntaxFactory.SeparatedList(constraints)));

45return SyntaxFactory.IdentifierName("var"); 77.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker) 79var refKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword); 80return SyntaxFactory.RefType(refKeyword, underlyingType); 87.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker) 89var refKeyword = SyntaxFactory.Token(SyntaxKind.RefKeyword); 90var readOnlyKeyword = SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword); 91return SyntaxFactory.RefType(refKeyword, readOnlyKeyword, underlyingType);

32syntax = syntax.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker).WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker); 67SyntaxFactory.AliasQualifiedName( 68SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)), 93SyntaxFactory.AliasQualifiedName( 94SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)), 107return AddInformationTo(SyntaxFactory.MemberAccessExpression(

41syntax = syntax.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker).WithAppendedTrailingTrivia(SyntaxFactory.ElasticMarker); 94ranks.Add(SyntaxFactory.ArrayRankSpecifier( 95SyntaxFactory.SeparatedList(Enumerable.Repeat<ExpressionSyntax>(SyntaxFactory.OmittedArraySizeExpression(), arrayType.Rank)))); 100TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList()); 104arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax); 111=> AddInformationTo(SyntaxFactory.IdentifierName("dynamic"), symbol); 117syntax = SyntaxFactory.IdentifierName(symbol.SpecialType == SpecialType.System_IntPtr ? "nint" : "nuint"); 149callingConventionSyntax = SyntaxFactory.FunctionPointerCallingConvention( 150SyntaxFactory.Token(SyntaxKind.UnmanagedKeyword), 152? SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.SeparatedList(conventionsList)) 156=> SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier(identifier)); 163.SelectAsArray(t => SyntaxFactory.FunctionPointerParameter(t.Type.GenerateTypeSyntax()).WithModifiers(t.RefKindModifiers)); 166SyntaxFactory.FunctionPointerType(callingConventionSyntax, SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.SeparatedList(parameters))), symbol); 199? Enumerable.Repeat((TypeSyntax)SyntaxFactory.OmittedTypeArgument(), symbol.TypeArguments.Length) 202return SyntaxFactory.GenericName( 204SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(typeArguments))); 209return SyntaxFactory.QualifiedName( 210SyntaxFactory.AliasQualifiedName( 212SyntaxFactory.IdentifierName("System")), 213SyntaxFactory.IdentifierName("Object")); 217=> SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)); 223return SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)); 238SyntaxFactory.NullableType(innerType.GenerateTypeSyntax()), symbol); 251var name = element.IsImplicitlyDeclared ? default : SyntaxFactory.Identifier(element.Name); 252list = list.Add(SyntaxFactory.TupleElement(element.Type.GenerateTypeSyntax(), name)); 255return AddInformationTo(SyntaxFactory.TupleType(list), symbol); 276SyntaxFactory.QualifiedName(name, simpleNameSyntax), 297typeSyntax = AddInformationTo(SyntaxFactory.QualifiedName( 307typeSyntax = AddInformationTo(SyntaxFactory.NullableType(typeSyntax), symbol); 328return AddInformationTo(SyntaxFactory.QualifiedName( 341SyntaxFactory.AliasQualifiedName( 351SyntaxFactory.PointerType(symbol.PointedAtType.GenerateTypeSyntax()), 362typeSyntax = AddInformationTo(SyntaxFactory.NullableType(typeSyntax), symbol);

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

24using static SyntaxFactory;

23private static readonly TypeParameterConstraintSyntax s_classConstraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint); 24private static readonly TypeParameterConstraintSyntax s_structConstraint = SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint); 25private static readonly TypeParameterConstraintSyntax s_defaultConstraint = SyntaxFactory.DefaultConstraint(); 120var methodDeclaration = SyntaxFactory.MethodDeclaration( 131semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default); 141var localFunctionDeclaration = SyntaxFactory.LocalFunctionStatement( 200attributes.AddRange(AttributeGenerator.GenerateAttributeLists(method.GetReturnTypeAttributes(), info, SyntaxFactory.Token(SyntaxKind.ReturnKeyword))); 238listOfClauses.Add(SyntaxFactory.TypeParameterConstraintClause( 240SyntaxFactory.SingletonSeparatedList(constraint))); 243return SyntaxFactory.List(listOfClauses); 261tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 264tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); 273tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 277tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 286tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 289tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 292tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); 297tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 300tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); 303tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); 306tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); 311tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 315tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); 318tokens.Add(SyntaxFactory.Token(SyntaxKind.NewKeyword)); 325tokens.Add(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); 331tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword));

201var compilationUnitWithoutUsings = compilationUnit.WithUsings(SyntaxFactory.List(compilationUnit.Usings.Where(u => u.GlobalKeyword != default))); 368var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

127return recordDeclaration.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 130recordDeclaration = recordDeclaration.WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken)) 131.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken)) 197var classOrStructKeyword = SyntaxFactory.Token(isRecordClass ? default : SyntaxKind.StructKeyword); 199typeDeclaration = SyntaxFactory.RecordDeclaration(kind: declarationKind, attributeLists: default, modifiers: default, 200SyntaxFactory.Token(SyntaxKind.RecordKeyword), classOrStructKeyword, namedType.Name.ToIdentifierToken(), 202SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 209typeDeclaration = SyntaxFactory.TypeDeclaration(kind, namedType.Name.ToIdentifierToken()); 230return SyntaxFactory.DelegateDeclaration( 246? SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList<BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(namedType.EnumUnderlyingType.GenerateTypeSyntax()))) 249return SyntaxFactory.EnumDeclaration( 279tokens.Add(SyntaxFactory.Token(SyntaxKind.FileKeyword)); 284tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 292tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 297tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); 304tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 309tokens.Add(SyntaxFactory.Token(SyntaxKind.RefKeyword)); 325types.Add(SyntaxFactory.SimpleBaseType(namedType.BaseType.GenerateTypeSyntax())); 328types.Add(SyntaxFactory.SimpleBaseType(type.GenerateTypeSyntax())); 333return SyntaxFactory.BaseList(SyntaxFactory.SeparatedList(types));

105return SyntaxFactory.CompilationUnit().WithUsings(usings); 111return SyntaxFactory.FileScopedNamespaceDeclaration(SyntaxFactory.ParseName(name)).WithUsings(usings); 114return SyntaxFactory.NamespaceDeclaration(SyntaxFactory.ParseName(name)).WithUsings(usings); 156return SyntaxFactory.UsingDirective( 157SyntaxFactory.NameEquals(alias.Name.ToIdentifierName()), 166return SyntaxFactory.UsingDirective(name); 177: SyntaxFactory.ParseName(symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat));

84var operatorToken = SyntaxFactory.Token(operatorSyntaxKind); 86? SyntaxFactory.Token(SyntaxKind.CheckedKeyword) 89var operatorDecl = SyntaxFactory.OperatorDeclaration( 94operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), 100semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()); 113tokens.Add(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); 116tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 120tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));

26return SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)); 38return SyntaxFactory.BracketedParameterList(SyntaxFactory.SeparatedList(parameters)); 67return SyntaxFactory.Parameter(parameter.Name.ToIdentifierToken()) 83list = list.Add(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 88list = list.Add(SyntaxFactory.Token(SyntaxKind.ParamsKeyword)); 108return SyntaxFactory.EqualsValueClause(

94var declaration = SyntaxFactory.IndexerDeclaration( 112? SyntaxFactory.EqualsValueClause(initializerNode) 119var propertyDeclaration = SyntaxFactory.PropertyDeclaration( 269: SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()); 292var declaration = SyntaxFactory.AccessorDeclaration(kind) 295.WithSemicolonToken(hasBody ? default : SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 304return SyntaxFactory.Block( 335modifiers.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 350tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 359tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 362tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 370tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 379tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 382tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); 385tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); 388tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); 391tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); 394tokens.Add(SyntaxFactory.Token(SyntaxKind.RequiredKeyword)); 399tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));

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

23return SyntaxFactory.SeparatedList<T>(nodesAndTokens.Add(SyntaxFactory.Token(separator)));

20return SyntaxFactory.Block(

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

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

21: SyntaxFactory.TypeParameterList( 22SyntaxFactory.SeparatedList(typeParameters.Select(t => GenerateTypeParameter(t, info)))); 28symbol.Variance == VarianceKind.In ? SyntaxFactory.Token(SyntaxKind.InKeyword) : 29symbol.Variance == VarianceKind.Out ? SyntaxFactory.Token(SyntaxKind.OutKeyword) : default; 31return SyntaxFactory.TypeParameter(

185newDeclaration = SyntaxFactory.DeclarationExpression(typeName, designation); 198builder.Add(SyntaxFactory.Argument(newDeclaration)); 201var separatorBuilder = ArrayBuilder<SyntaxToken>.GetInstance(builder.Count - 1, SyntaxFactory.Token(leading: default, SyntaxKind.CommaToken, trailing: default)); 203return SyntaxFactory.TupleExpression( 204SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithTrailingTrivia(), 205SyntaxFactory.SeparatedList(builder.ToImmutable(), separatorBuilder.ToImmutableAndFree()), 206SyntaxFactory.Token(SyntaxKind.CloseParenToken))

44updatedDecl = updatedDecl.WithArrowToken(updatedDecl.ArrowToken.WithTrailingTrivia(SyntaxFactory.ElasticSpace)); 67return currentDeclaration.WithBody(SyntaxFactory.Block( 68SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed), 69SyntaxFactory.SingletonList(statement), 70SyntaxFactory.Token(SyntaxKind.CloseBraceToken)));

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

10using static SyntaxFactory;

29using static SyntaxFactory;

176arguments.Add(SyntaxFactory.Argument(stringLiteral)); 183return argumentList.WithArguments(SyntaxFactory.SeparatedList<ArgumentSyntax>(arguments)); 193var stringLiteral = SyntaxFactory.LiteralExpression(SyntaxKind.Utf8StringLiteralExpression, 194SyntaxFactory.Token( 208return SyntaxFactory.InvocationExpression( 209SyntaxFactory.MemberAccessExpression( 212SyntaxFactory.IdentifierName(nameof(ReadOnlySpan<byte>.ToArray))))

9191var tree = SyntaxFactory.ParseSyntaxTree("class C public { }", path: "goo"); 9438var syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "filename.cs"); 9450syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "filename.cs"); 9458syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "filename.cs"); 11855new[] { SyntaxFactory.ParseSyntaxTree(minSystemCollectionsImmutableSource) }, 11863new[] { SyntaxFactory.ParseSyntaxTree(minCodeAnalysisSource) }, 11961new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(analyzerSource) },

185BaseFieldDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 186BaseMethodDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 187BasePropertyDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 188StatementSyntax => SyntaxFactory.ParseStatement(textToParse, options: (CSharpParseOptions)tree.Options), 189UsingDirectiveSyntax => SyntaxFactory.ParseCompilationUnit(textToParse, options: (CSharpParseOptions)tree.Options),

397SyntaxFactory.Token(SyntaxKind.SemicolonToken).WithTrailingTrivia(objectCreationNodeWithCorrectInitializer.GetTrailingTrivia()), 430var newArgumentList = SyntaxFactory.ArgumentList().WithTrailingTrivia(newKeywordToken.TrailingTrivia); 431return SyntaxFactory.ImplicitObjectCreationExpression(newKeywordToken.WithoutTrailingTrivia(), newArgumentList, baseObjectCreationExpressionNode.Initializer); 438var newArgumentList = SyntaxFactory.ArgumentList().WithTrailingTrivia(typeNode.GetTrailingTrivia()); 447var newArgumentList = SyntaxFactory.ArgumentList().WithTrailingTrivia(newKeywordToken.TrailingTrivia); 448return SyntaxFactory.ImplicitObjectCreationExpression(newKeywordToken.WithoutTrailingTrivia(), newArgumentList, baseObjectCreationExpressionNode.Initializer); 837=> SyntaxFactory.AccessorList().WithOpenBraceToken(GetOpenBrace(formattingOptions)).WithCloseBraceToken(GetCloseBrace(formattingOptions)); 840=> SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression) 844=> SyntaxFactory.Block().WithOpenBraceToken(GetOpenBrace(formattingOptions)).WithCloseBraceToken(GetCloseBrace(formattingOptions)); 847=> SyntaxFactory.Token( 854=> SyntaxFactory.Token( 862return SyntaxFactory.EndOfLine(newLineString); 888.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 906.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); 916.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); 926.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); 1004=> SyntaxFactory.FieldDeclaration( 1007SyntaxFactory.VariableDeclaration( 1009SyntaxFactory.SingletonSeparatedList( 1010SyntaxFactory.VariableDeclarator(propertyDeclarationNode.Identifier))), 1011SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 1018=> SyntaxFactory.EventFieldDeclaration( 1021SyntaxFactory.VariableDeclaration( 1023SyntaxFactory.SingletonSeparatedList( 1024SyntaxFactory.VariableDeclarator(eventDeclarationNode.Identifier)))); 1032SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.SemicolonToken, SyntaxTriviaList.Empty));

129var regionTrivia = SyntaxFactory.RegionDirectiveTrivia(true) 130.WithTrailingTrivia(new[] { SyntaxFactory.Space, SyntaxFactory.PreprocessingMessage(assemblyInfo) }); 135SyntaxFactory.Trivia(regionTrivia), 136SyntaxFactory.CarriageReturnLineFeed, 137SyntaxFactory.Comment("// " + assemblyPath), 138SyntaxFactory.CarriageReturnLineFeed, 139SyntaxFactory.Comment($"// Decompiled with ICSharpCode.Decompiler {s_decompilerVersion.FileVersion}"), 140SyntaxFactory.CarriageReturnLineFeed, 141SyntaxFactory.Trivia(SyntaxFactory.EndRegionDirectiveTrivia(true)), 142SyntaxFactory.CarriageReturnLineFeed, 143SyntaxFactory.CarriageReturnLineFeed

48=> SyntaxFactory.IsCompleteSubmission(SyntaxFactory.ParseSyntaxTree(SourceText.From(text, encoding: null, SourceHashAlgorithms.Default), options: s_parseOptions));

31var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(code, encoding: null, SourceHashAlgorithms.Default), options);

43=> SyntaxFactory.ParseSyntaxTree(GetTestFileContent()); 46=> SyntaxFactory.ParseSyntaxTree(code);

77var newNode = SyntaxFactory.MemberAccessExpression( 79SyntaxFactory.ThisExpression(),

40var tree = SyntaxFactory.ParseSyntaxTree(source, options); 74var tree = SyntaxFactory.ParseSyntaxTree(source);

52var tree = SyntaxFactory.ParseSyntaxTree(source); 458var root = SyntaxFactory.ParseCompilationUnit(source, options: experimental);

82=> SyntaxFactory.ParseSyntaxTree( 166return ((BaseMethodDeclarationSyntax)SyntaxFactory.SyntaxTree(declaration).GetRoot()).Body; 169return (BlockSyntax)SyntaxFactory.SyntaxTree(declaration.Body).GetRoot(); 182=> new(oldSource, newSource, source => SyntaxFactory.ParseSyntaxTree(source, path: GetDocumentFilePath(documentIndex)), flags); 190var body1 = ((MethodDeclarationSyntax)SyntaxFactory.SyntaxTree(decl1).GetRoot()).Body; 193var body2 = ((MethodDeclarationSyntax)SyntaxFactory.SyntaxTree(decl2).GetRoot()).Body;

20=> SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(n)); 58new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword) }, 59new[] { SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword) }); 74ImmutableArray.Create(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)), 75ImmutableArray.Create(SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword))); 110new[] { SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword) }, 111new[] { SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword) }); 120ImmutableArray.Create(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword)), 121ImmutableArray.Create(SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.AsyncKeyword))); 129var distance = SyntaxComparer.ComputeDistance(SyntaxFactory.Literal("abc", "abc"), SyntaxFactory.Literal("acb", "acb")); 145ImmutableArray.Create(SyntaxFactory.Token(SyntaxKind.StaticKeyword)));

20var oldRoot = SyntaxFactory.ParseSyntaxTree(oldSource).GetRoot(); 21var newRoot = SyntaxFactory.ParseSyntaxTree(newSource).GetRoot(); 26Assert.True(SyntaxFactory.AreEquivalent(oldNode, newNode), $"Node '{oldNode}' not equivalent to '{newNode}'."); 72var leftRoot = SyntaxFactory.ParseSyntaxTree(@" 87var rightRoot = SyntaxFactory.ParseSyntaxTree(@" 115var leftRoot = SyntaxFactory.ParseSyntaxTree(@" 134var rightRoot = SyntaxFactory.ParseSyntaxTree(@" 163var tree = SyntaxFactory.ParseSyntaxTree(@" 224var tree = SyntaxFactory.ParseSyntaxTree(@"

39var tree = SyntaxFactory.ParseSyntaxTree(text, options: options); 61var tree = SyntaxFactory.ParseSyntaxTree(text, options: options); 88var tree = SyntaxFactory.ParseSyntaxTree(text, options: options);

42var root = SyntaxFactory.ParseCompilationUnit(code); 51var newRoot = rootWithAnnotation.ReplaceToken(publicToken, SyntaxFactory.Token(SyntaxKind.PrivateKeyword)); 87var root = SyntaxFactory.ParseCompilationUnit(code); 96var newRoot = rootWithAnnotation.ReplaceToken(publicToken, SyntaxFactory.Token(SyntaxKind.PrivateKeyword));

23=> SyntaxFactory.ParseCompilationUnit(expected);

1579var node = SyntaxFactory.ParseExpression(code); 2019var tree = SyntaxFactory.ParseSyntaxTree(code, options: TestOptions.Script); 2022var entry = SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression), SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));

264.AddSyntaxTrees(sources.Select((s, i) => SyntaxFactory.ParseSyntaxTree(s, options: parseOptions, path: sourceCodePaths[i])))

502=> SyntaxFactory.ParseSyntaxTree(text);

294var originalComp = CreateCompilation(new[] { SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs") }, assemblyName: "Test"); 295var newComp = CreateCompilation(new[] { SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs") }, assemblyName: "Test"); 308var src1 = SyntaxFactory.ParseSyntaxTree(@"using System; 316var src2 = SyntaxFactory.ParseSyntaxTree(@"

35var parsedStatement = SyntaxFactory.ParseStatement(statement);

34var parsedStatement = SyntaxFactory.ParseStatement(statement);

63var tree = SyntaxFactory.ParseSyntaxTree(text, options: options);

26SyntaxFactory.ParseSyntaxTree(test).GetDiagnostics().Verify(Diagnostic(ErrorCode.ERR_PPDirectiveExpected, @"de\u0066in\U00000065")); 279SyntaxFactory.ParseSyntaxTree(test).GetDiagnostics().Verify(Diagnostic(ErrorCode.ERR_GlobalAttributesNotFirst, "assembly"));

4538var s0 = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), references); 4539var s1 = CSharpCompilation.CreateScriptCompilation("s1.dll", SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Script), references, previousScriptCompilation: s0); 4549var s0 = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), references);

2918var nodeToSpeculate = SyntaxFactory.ParseExpression("x + y"); 2950var nodeToSpeculate = SyntaxFactory.ParseExpression("x + y");

654trees.Add(SyntaxFactory.ParseSyntaxTree("System.Console.WriteLine(" + i + ");", options: TestOptions.Script));

25var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 44var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 62var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 88var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 113var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 138var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 169var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 197var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 555SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), 636var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);

22645var startTree = SyntaxFactory.ParseSyntaxTree(text); 24047var tree = SyntaxFactory.ParseSyntaxTree(text, CSharpParseOptions.Default);

891var s0 = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), references); 893var s1 = CSharpCompilation.CreateScriptCompilation("s1.dll", SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Script), references, previousScriptCompilation: s0); 1002var s0 = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), references); 1004var s1 = CSharpCompilation.CreateScriptCompilation("s1.dll", SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Script), references, previousScriptCompilation: s0);

91if (!SyntaxFactory.AreEquivalent(s0, s1)) 98if (SyntaxFactory.AreEquivalent(p0, p1))

2229var syntax = SyntaxFactory.ParseSyntaxTree(@"class C {}", TestOptions.Regular.WithNoRefSafetyRulesAttribute()); 2418var syntax = SyntaxFactory.ParseSyntaxTree(@"class C { static void Main() { } }", TestOptions.Regular.WithNoRefSafetyRulesAttribute());

374SyntaxFactory.ParseSyntaxTree(csx, options: TestOptions.Script), 395SyntaxFactory.ParseSyntaxTree(csx, options: TestOptions.Script), 726new[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Script) }, 749SyntaxFactory.ParseSyntaxTree(csx, options: TestOptions.Script), 750SyntaxFactory.ParseSyntaxTree(cs, options: TestOptions.Regular) 783SyntaxFactory.ParseSyntaxTree(csx, options: TestOptions.Script), 784SyntaxFactory.ParseSyntaxTree(cs, options: TestOptions.Regular) 930SyntaxFactory.ParseSyntaxTree(csx, options: TestOptions.Script), 931SyntaxFactory.ParseSyntaxTree(cs, options: TestOptions.Regular),

448var sourceTree = SyntaxFactory.ParseSyntaxTree("");

34var tree1 = SyntaxFactory.ParseSyntaxTree(StringText.From(source1, Encoding.UTF8, SourceHashAlgorithm.Sha1), path: "sha1.cs"); 35var tree256 = SyntaxFactory.ParseSyntaxTree(StringText.From(source256, Encoding.UTF8, SourceHashAlgorithm.Sha256), path: "sha256.cs");

38var tree1 = SyntaxFactory.ParseSyntaxTree("class A { }", encoding: null, path: "Foo.cs"); 39var tree2 = SyntaxFactory.ParseSyntaxTree("class B { }", encoding: null, path: ""); 40var tree3 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class C { }", encoding: null), path: "Bar.cs"); 41var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 58var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 59var tree2 = SyntaxFactory.ParseSyntaxTree("class B { public void F() { } }", encoding: null, path: ""); 60var tree3 = SyntaxFactory.ParseSyntaxTree("class C { public void F() { } }", encoding: new UTF8Encoding(true, false), path: "Bar.cs"); 61var tree4 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class D { public void F() { } }", new UTF8Encoding(false, false)), path: "Baz.cs"); 125var tree1 = SyntaxFactory.ParseCompilationUnit(@" 129var tree2 = SyntaxFactory.ParseCompilationUnit(@" 12290var tree = SyntaxFactory.ParseSyntaxTree(source, encoding: Encoding.UTF8, path: "HIDDEN.cs");

463var trees = sources.Select((s, i) => SyntaxFactory.ParseSyntaxTree(s, path: $"{i + 1}.cs", encoding: Encoding.UTF8)).ToArray();

53var typeForwardedTo = SyntaxFactory.Attribute(SyntaxFactory.ParseName("TypeForwardedTo")); 54var typeIdentifier = SyntaxFactory.Attribute(SyntaxFactory.ParseName("TypeIdentifier")); 64var alias1 = SyntaxFactory.Attribute(SyntaxFactory.ParseName("alias1")); 74var alias2 = SyntaxFactory.Attribute(SyntaxFactory.ParseName("alias2")); 81var alias3 = SyntaxFactory.Attribute(SyntaxFactory.ParseName("alias3")); 752var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 774var result = SyntaxFactory.ParseAttributeArgumentList("[]"); 784var result = SyntaxFactory.ParseAttributeArgumentList("[]", consumeFullText: false); 817var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 858var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 899var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 938var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 4593SyntaxFactory.ParseSyntaxTree(

4156SyntaxFactory.ParseSyntaxTree(source1, path: @"C:\filename", encoding: Encoding.UTF8), 4157SyntaxFactory.ParseSyntaxTree(source2, path: @"a\b\..\c\d", encoding: Encoding.UTF8), 4158SyntaxFactory.ParseSyntaxTree(source3, path: @"*", encoding: Encoding.UTF8), 4159SyntaxFactory.ParseSyntaxTree(source4, path: @" ", encoding: Encoding.UTF8), 4198SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Regular9, path: @"C:\filename", encoding: Encoding.UTF8) 4251SyntaxFactory.ParseSyntaxTree(source1, path: @"C:\filename", encoding: Encoding.UTF8), 4252SyntaxFactory.ParseSyntaxTree(source2, path: @"a\b\..\c\d.cs", encoding: Encoding.UTF8), 4253SyntaxFactory.ParseSyntaxTree(source3, path: @"*", encoding: Encoding.UTF8), 4254SyntaxFactory.ParseSyntaxTree(source4, path: @"C:\x.cs", encoding: Encoding.UTF8), 4255SyntaxFactory.ParseSyntaxTree(source5, path: @"C:\x.cs", encoding: Encoding.UTF8), 5158new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5209new[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular7, path: @"C:\filename", encoding: Encoding.UTF8) }, 5279var compilation = CreateCompilationWithMscorlib45(new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular7, path: @"C:\filename") }).VerifyDiagnostics( 5542new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5602new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5657new[] { SyntaxFactory.ParseSyntaxTree(csSource, path: @"C:\filename", encoding: Encoding.UTF8) },

250CompilationUnitSyntax root = SyntaxFactory.ParseCompilationUnit(testSource); 251var syntaxTree = SyntaxFactory.SyntaxTree(root); 461CompilationUnitSyntax root = SyntaxFactory.ParseCompilationUnit(testSource); 462var syntaxTree = SyntaxFactory.SyntaxTree(root);

1381var newInvocation = SyntaxFactory.ParseExpression("Process((in int x) => x)"); 1423var newInvocation = SyntaxFactory.ParseExpression("Process(() => ref x)"); 1452var localfunction = SyntaxFactory.ParseStatement("int localFunction(in int x) { return x; }"); 1479var localfunction = SyntaxFactory.ParseStatement("ref readonly int localFunction(int x) { return ref x; }");

900var tree = SyntaxFactory.ParseSyntaxTree(@"

5483var tree = SyntaxFactory.ParseSyntaxTree(source);

4173SyntaxFactory.ParseExpression("A is B < C, D > E").GetDiagnostics().Verify(); 4174SyntaxFactory.ParseExpression("A as B < C, D > E").GetDiagnostics().Verify( 4180SyntaxFactory.ParseExpression("A as B < C, D > ?? string.Empty").GetDiagnostics().Verify(); 4181SyntaxFactory.ParseExpression("A is B < C, D > ?? string.Empty").GetDiagnostics().Verify(

403var statement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement(@" 708var statement = (ReturnStatementSyntax)SyntaxFactory.ParseStatement(@" 977var statement = (ThrowStatementSyntax)SyntaxFactory.ParseStatement(@" 1281var statement = (IfStatementSyntax)SyntaxFactory.ParseStatement(@" 5337var statement = (SwitchStatementSyntax)SyntaxFactory.ParseStatement(@" 6467var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@" 6880var statement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement(@" 7207var statement = (WhileStatementSyntax)SyntaxFactory.ParseStatement(@" 7530var statement = (DoStatementSyntax)SyntaxFactory.ParseStatement(@" 9636var statement = (LockStatementSyntax)SyntaxFactory.ParseStatement(@" 10199var statement = (YieldStatementSyntax)SyntaxFactory.ParseStatement(@" 10715var statement = (LabeledStatementSyntax)SyntaxFactory.ParseStatement(@" 12142var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@"

365var syntax = SyntaxFactory.IdentifierName(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)); 625var syntax = SyntaxFactory.IdentifierName(localName); 640var syntax = SyntaxFactory.IdentifierName(parameterName); 653var syntax = SyntaxFactory.ThisExpression(); 665var syntax = SyntaxFactory.IdentifierName(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)); 1212syntax = SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword));

268var identifierName = SyntaxFactory.IdentifierName(builder.ToString()); 274: SyntaxFactory.QualifiedName(output, identifierName); 294var finalIdentifierName = SyntaxFactory.IdentifierName(builder.ToString()); 297: SyntaxFactory.QualifiedName(output, finalIdentifierName); 311return SyntaxFactory.QualifiedName( 317return SyntaxFactory.AliasQualifiedName(externAliasSyntax, (SimpleNameSyntax)nameSyntax);

728var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular11, path: "path/to/MyFile.cs", Encoding.Default), options: TestOptions.DebugDll); 787SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Regular11, path: "path/to/Source1.cs", Encoding.Default), 788SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.Regular11, path: "path/to/Source2.cs", Encoding.Default) 855SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Regular11, path: "path/to/Source1.cs", Encoding.Default), 856SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.Regular11, path: "path/to/Source2.cs", Encoding.Default) 912SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Regular11, path: "path/to/Source1.cs", Encoding.Default), 913SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.Regular11, path: "path/to/Source2.cs", Encoding.Default) 948var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular11, path: "path/to/MyFile.cs", Encoding.Default), options: TestOptions.DebugDll); 994var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular11, path: "path/to/MyFile.cs", Encoding.Default), options: TestOptions.DebugDll); 1069SyntaxFactory.ParseSyntaxTree(sourceA, path: "path/to/A.cs", encoding: Encoding.Default), 1070SyntaxFactory.ParseSyntaxTree(sourceB, path: "path/to/B.cs", encoding: Encoding.Default), 1071SyntaxFactory.ParseSyntaxTree(sourceC, path: "path/to/C.cs", encoding: Encoding.Default), 1154var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular11, path: "path/to/\uD800.cs", Encoding.Default), options: TestOptions.DebugDll); 1206SyntaxFactory.ParseSyntaxTree(sourceA, path: "A.cs", encoding: Encoding.Default), 1207SyntaxFactory.ParseSyntaxTree(sourceB, path: "B.cs", encoding: Encoding.Default) 1389SyntaxFactory.ParseSyntaxTree(sourceA, path: "A.cs", encoding: Encoding.Default), 1390SyntaxFactory.ParseSyntaxTree(sourceB, path: "B.cs", encoding: Encoding.Default), 1391SyntaxFactory.ParseSyntaxTree(sourceC, path: "C.cs", encoding: Encoding.Default),

33return SyntaxFactory.Comment(text);

394var usingDirective = SyntaxFactory.UsingDirective( 414var namePiece = SyntaxFactory.IdentifierName(part); 417: SyntaxFactory.QualifiedName(CreateNameSyntax(namespaceParts, index - 1), namePiece); 431return (SyntaxFactory.ExternAliasDirective(SyntaxFactory.Identifier(val)) 455var dummyUsing = SyntaxFactory.UsingDirective(nameSyntax); 468nameSyntax = AddOrReplaceAlias(nameSyntax, SyntaxFactory.IdentifierName(externAlias)); 484var usingDirective = SyntaxFactory.UsingDirective(nameSyntax) 489: usingDirective.WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 545return SyntaxFactory.AliasQualifiedName(alias, simpleName);

26using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

51var dummyStatement = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( 53SyntaxFactory.IdentifierName("_"), 54SyntaxFactory.IsPatternExpression( 56SyntaxFactory.ConstantPattern(SyntaxFactory.ParenthesizedExpression(binaryExpression.Right.WithAdditionalAnnotations(s_annotation))) 164if (!SyntaxFactory.AreEquivalent(target.Syntax, compareTarget.Syntax))

24=> oldArgumentList.WithArguments(SyntaxFactory.SeparatedList(newArguments));

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

24=> oldArgumentList.WithArguments(SyntaxFactory.SeparatedList(newArguments));

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

29using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

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

37var restoreKeyword = SyntaxFactory.Token(SyntaxKind.RestoreKeyword); 44var disableKeyword = SyntaxFactory.Token(SyntaxKind.DisableKeyword); 52var id = SyntaxFactory.IdentifierName(diagnosticId); 54var pragmaDirective = SyntaxFactory.PragmaWarningDirectiveTrivia(disableOrRestoreKeyword, ids, true); 56var pragmaDirectiveTrivia = SyntaxFactory.Trivia(pragmaDirective); 57var endOfLineTrivia = SyntaxFactory.CarriageReturnLineFeed; 58var triviaList = SyntaxFactory.TriviaList(pragmaDirectiveTrivia); 63var titleComment = SyntaxFactory.Comment(string.Format(" // {0}", title)).WithAdditionalAnnotations(Formatter.Annotation); 122compilationRoot = compilationRoot.WithLeadingTrivia(SyntaxFactory.Comment(GlobalSuppressionsFileHeaderComment)); 159.Add(SyntaxFactory.Attribute(attributeName, attributeArguments)); 164var targetSpecifier = SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword)); 165attributeList = SyntaxFactory.AttributeList(targetSpecifier, attributes); 169attributeList = SyntaxFactory.AttributeList(attributes); 178var category = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(diagnostic.Descriptor.Category)); 179var categoryArgument = SyntaxFactory.AttributeArgument(category); 183var ruleId = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(ruleIdText)); 184var ruleIdArgument = SyntaxFactory.AttributeArgument(ruleId); 186var justificationExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(FeaturesResources.Pending)); 187var justificationArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Justification"), nameColon: null, expression: justificationExpr); 189var attributeArgumentList = SyntaxFactory.AttributeArgumentList().AddArguments(categoryArgument, ruleIdArgument, justificationArgument); 196var scopeExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(scopeString)); 197var scopeArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Scope"), nameColon: null, expression: scopeExpr); 200var targetExpr = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(targetString)); 201var targetArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.NameEquals("Target"), nameColon: null, expression: targetExpr); 240var toggledToken = SyntaxFactory.Token(currentKeyword.LeadingTrivia, toggledKeywordKind, currentKeyword.TrailingTrivia); 242return SyntaxFactory.Trivia(newPragmaWarning);

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

138return rewrittenNode.WithSettingToken(SyntaxFactory.Token(SyntaxKind.DisableKeyword).WithTriviaFrom(rewrittenNode.SettingToken)); 143return rewrittenNode.WithSettingToken(SyntaxFactory.Token(SyntaxKind.RestoreKeyword).WithTriviaFrom(rewrittenNode.SettingToken)); 156var newLine = SyntaxFactory.EndOfLine(options.NewLine); 161var nullableDisableTrivia = SyntaxFactory.Trivia(SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.DisableKeyword).WithPrependedLeadingTrivia(SyntaxFactory.ElasticSpace), isActive: true)); 172return root.ReplaceTrivia(leadingDirective.ParentTrivia, SyntaxFactory.ElasticMarker);

354var newLabeledStatement = labeledStatement.ReplaceNode(newLocalDeclaration, SyntaxFactory.ParseStatement("")); 397return SyntaxFactory.ObjectCreationExpression(implicitCreation.NewKeyword, type, implicitCreation.ArgumentList, implicitCreation.Initializer); 415return SyntaxFactory.ArrayCreationExpression(arrayType, arrayInitializer);

71SyntaxFactory.NameEquals(identifier), UpdateIdentifier(identifier)).WithTriviaFrom(node); 84SyntaxFactory.NameColon(identifier), node.RefKindKeyword, UpdateIdentifier(identifier)).WithTriviaFrom(node);

142newNode = SyntaxFactory.QualifiedName(qualifiedNamespaceName, nameRef.WithoutTrivia()); 159newNode = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, memberAccessNamespaceName, nameRef.WithoutTrivia()); 182newNode = SyntaxFactory.TypeCref((AliasQualifiedNameSyntax)newNode!); 211var aliasNode = aliasQualifier?.ToIdentifierName() ?? SyntaxFactory.IdentifierName(SyntaxFactory.Token(SyntaxKind.GlobalKeyword)); 212newNode = SyntaxFactory.AliasQualifiedName(aliasNode, nameNode.WithoutTrivia()); 313var targetNamespaceDecl = SyntaxFactory.NamespaceDeclaration( 416var namePiece = SyntaxFactory.IdentifierName(part); 419return aliasQualifier == null ? namePiece : SyntaxFactory.AliasQualifiedName(aliasQualifier, namePiece); 421return SyntaxFactory.QualifiedName(CreateNamespaceAsQualifiedName(namespaceParts, aliasQualifier, index - 1), namePiece); 429var namePiece = SyntaxFactory.IdentifierName(part); 435: SyntaxFactory.AliasQualifiedName(aliasQualifier, namePiece); 438return SyntaxFactory.MemberAccessExpression(

30using static SyntaxFactory; 371return SyntaxFactory.Subpattern(ExpressionColon(expression, Token(ColonToken)), pattern); 383=> SyntaxFactory.Subpattern(NameColon(name), pattern); 386=> SyntaxFactory.RecursivePattern(type: null, positionalPatternClause: null, PropertyPatternClause(SeparatedList(subpatterns)), designation: null); 389=> SyntaxFactory.RecursivePattern(type, positionalPatternClause: null, PropertyPatternClause(SingletonSeparatedList(subpattern)), designation);

47var syntax = SyntaxFactory.Argument( 49refKindKeyword: SyntaxFactory.Token(SyntaxKind.OutKeyword), 50SyntaxFactory.DeclarationExpression( 51type: SyntaxFactory.IdentifierName("var"), 52designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier( 53SyntaxFactory.TriviaList(), 57SyntaxFactory.TriviaList()))));

82.WithTrailingTrivia(SyntaxFactory.Space); 101replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

35return SyntaxFactory.ObjectCreationExpression( 40=> SyntaxFactory.ArgumentList( 41SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithTriviaFrom(anonymousObject.OpenBraceToken), 43SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTriviaFrom(anonymousObject.CloseBraceToken)); 46=> SyntaxFactory.SeparatedList<ArgumentSyntax>(CreateArguments(OmitTrailingComma(initializers.GetWithSeparators()))); 75=> SyntaxFactory.Argument(decl.Expression);

32=> SyntaxFactory.TupleExpression( 33SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithTriviaFrom(anonCreation.OpenBraceToken), 35SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTriviaFrom(anonCreation.CloseBraceToken)) 39=> SyntaxFactory.SeparatedList(initializers.Select(ConvertInitializer), initializers.GetSeparators()); 42=> SyntaxFactory.Argument(ConvertName(declarator.NameEquals), default, declarator.Expression) 48: SyntaxFactory.NameColon( 50SyntaxFactory.Token(SyntaxKind.ColonToken).WithTriviaFrom(nameEquals.EqualsToken));

106var blockSyntax = SyntaxFactory.Block( 107SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed), 109SyntaxFactory.Token(SyntaxKind.CloseBraceToken)

68var newStartToken = SyntaxFactory.Token( 75SyntaxFactory.List(newContents), 80=> SyntaxFactory.Token(

58=> SyntaxFactory.Token(

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

87var forStatement = SyntaxFactory.ForStatement( 88SyntaxFactory.VariableDeclaration( 90SyntaxFactory.SingletonSeparatedList( 91SyntaxFactory.VariableDeclarator( 94SyntaxFactory.EqualsValueClause((ExpressionSyntax)generator.LiteralExpression(0))))), 95SyntaxFactory.SeparatedList<ExpressionSyntax>(), 99SyntaxFactory.SingletonSeparatedList<ExpressionSyntax>( 100SyntaxFactory.PostfixUnaryExpression( 101SyntaxKind.PostIncrementExpression, SyntaxFactory.IdentifierName(indexVariable))), 132var bodyBlock = foreachStatement.Statement is BlockSyntax block ? block : SyntaxFactory.Block(foreachStatement.Statement);

37: SyntaxFactory.SingletonList(forStatement.Statement); 119return SyntaxFactory.ForEachStatement( 120SyntaxFactory.Token(SyntaxKind.ForEachKeyword).WithTriviaFrom(forStatement.ForKeyword), 124SyntaxFactory.Token(SyntaxKind.InKeyword),

18using static SyntaxFactory;

60=> SyntaxFactory.QueryExpression( 62SyntaxFactory.QueryBody( 63SyntaxFactory.List(ForEachInfo.ConvertingExtendedNodes.Select(node => CreateQueryClause(node))), 64SyntaxFactory.SelectClause(selectExpression) 75return SyntaxFactory.LetClause( 76SyntaxFactory.Token(SyntaxKind.LetKeyword), 87return SyntaxFactory.WhereClause( 88SyntaxFactory.Token(SyntaxKind.WhereKeyword) 101=> SyntaxFactory.FromClause( 102fromKeyword: SyntaxFactory.Token(SyntaxKind.FromKeyword) 168var lambda = SyntaxFactory.SimpleLambdaExpression( 169SyntaxFactory.Parameter( 207return SyntaxFactory.InvocationExpression( 208SyntaxFactory.MemberAccessExpression( 211SyntaxFactory.IdentifierName(invokedMethodName)), 212SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( 213SyntaxFactory.Argument(lambda)))); 276var lambdaParameter = SyntaxFactory.Parameter(SyntaxFactory.Identifier(parentForEachStatement.Identifier.ValueText)); 277var lambda = SyntaxFactory.SimpleLambdaExpression( 278SyntaxFactory.Parameter( 279SyntaxFactory.Identifier(parentForEachStatement.Identifier.ValueText)), 283receiver = SyntaxFactory.InvocationExpression( 284SyntaxFactory.MemberAccessExpression( 287SyntaxFactory.IdentifierName(nameof(Enumerable.Where))), 288SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( 289SyntaxFactory.Argument(lambda))));

189=> SyntaxFactory.InvocationExpression( 190SyntaxFactory.MemberAccessExpression( 193SyntaxFactory.IdentifierName(MethodName))).WithAdditionalAnnotations(Formatter.Annotation);

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

21private static readonly TypeSyntax VarNameIdentifier = SyntaxFactory.IdentifierName("var"); 56return SyntaxFactory.ForEachStatement( 58SyntaxFactory.Identifier("_"), 60SyntaxFactory.AnonymousObjectCreationExpression(), 69return SyntaxFactory.ForEachStatement( 73SyntaxFactory.IdentifierName(identifiers.Single()), 81var tupleForSelectExpression = SyntaxFactory.TupleExpression( 82SyntaxFactory.SeparatedList(identifiers.Select( 83identifier => SyntaxFactory.Argument(SyntaxFactory.IdentifierName(identifier))))); 84var declaration = SyntaxFactory.DeclarationExpression( 86SyntaxFactory.ParenthesizedVariableDesignation( 87SyntaxFactory.SeparatedList<VariableDesignationSyntax>(identifiers.Select( 88identifier => SyntaxFactory.SingleVariableDesignation(identifier))))); 91return SyntaxFactory.ForEachVariableStatement( 103=> statements is [BlockSyntax block] ? block : SyntaxFactory.Block(statements);

47=> SyntaxFactory.ExpressionStatement( 48SyntaxFactory.AssignmentExpression(

52=> SyntaxFactory.ExpressionStatement( 53SyntaxFactory.InvocationExpression( 54SyntaxFactory.MemberAccessExpression( 57SyntaxFactory.IdentifierName(nameof(List<object>.AddRange))), 58SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(queryOrLinqInvocationExpression)))));

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

30private static readonly TypeSyntax VarNameIdentifier = SyntaxFactory.IdentifierName("var"); 103documentUpdateInfo = new DocumentUpdateInfo(documentUpdateInfo.Source, SyntaxFactory.Block(documentUpdateInfo.Destinations)); 124return SyntaxFactory.Block(SyntaxFactory.IfStatement(((WhereClauseSyntax)node).Condition.WithAdditionalAnnotations(Simplifier.Annotation).WithoutTrivia(), statement)); 141expression1 = SyntaxFactory.IdentifierName(variable); 148return SyntaxFactory.ForEachStatement( 186expression2 = SyntaxFactory.IdentifierName(variable); 197return SyntaxFactory.Block( 198SyntaxFactory.ForEachStatement( 202SyntaxFactory.Block( 203SyntaxFactory.IfStatement( 204SyntaxFactory.InvocationExpression( 205SyntaxFactory.MemberAccessExpression( 207SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)), 208SyntaxFactory.IdentifierName(nameof(object.Equals))), 209SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( 211SyntaxFactory.Argument(joinClause.LeftExpression), 212SyntaxFactory.Argument(joinClause.RightExpression.WithoutTrailingTrivia())}))), 324(variableIdentifier, expression) => SyntaxFactory.ExpressionStatement( 325SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, variableIdentifier)), // Generating 'count++' 326SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(0)), // count = 0 356(listIdentifier, expression) => SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression( 357SyntaxFactory.MemberAccessExpression( 360SyntaxFactory.IdentifierName(nameof(IList.Add))), 361SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(expression))))), 362SyntaxFactory.ObjectCreationExpression( 364SyntaxFactory.ArgumentList(), 458variableLocal = SyntaxFactory.IdentifierName(symbolName); 477SyntaxFactory.IdentifierName(variableDeclarator.Identifier), 507variable = SyntaxFactory.IdentifierName(symbolName); 509nodesAfter = new[] { SyntaxFactory.ReturnStatement(variable).WithAdditionalAnnotations(Simplifier.Annotation) }; 530return SyntaxFactory.LocalDeclarationStatement( 531SyntaxFactory.VariableDeclaration( 533SyntaxFactory.SingletonSeparatedList( 534SyntaxFactory.VariableDeclarator( 537SyntaxFactory.EqualsValueClause(expression))))).WithAdditionalAnnotations(Simplifier.Annotation); 580=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, expression); 589var localFunctionDeclaration = SyntaxFactory.LocalFunctionStatement( 594parameterList: SyntaxFactory.ParameterList(), 596body: SyntaxFactory.Block( 597SyntaxFactory.Token( 598SyntaxFactory.TriviaList(), 600SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine(Environment.NewLine))), 601SyntaxFactory.List(statements), 602SyntaxFactory.Token(SyntaxKind.CloseBraceToken)), 605var localFunctionInvocation = SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName(localFunctionToken)).WithAdditionalAnnotations(Simplifier.Annotation); 701expression => AddToBlockTop(SyntaxFactory.LocalDeclarationStatement( 702SyntaxFactory.VariableDeclaration( 704SyntaxFactory.SingletonSeparatedList( 705SyntaxFactory.VariableDeclarator( 708SyntaxFactory.EqualsValueClause(expression))))), 773=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, expression), queryExpressionProcessingInfo); 776var yieldBreakStatement = SyntaxFactory.YieldStatement(SyntaxKind.YieldBreakStatement); 910return SyntaxFactory.Block(newStatement, statement); 928=> statement is BlockSyntax block ? block : SyntaxFactory.Block(statement);

190var semiColon = SyntaxFactory.Token(SyntaxKind.SemicolonToken) 199var fileScopedNamespace = SyntaxFactory.FileScopedNamespaceDeclaration( 248var namespaceDeclaration = SyntaxFactory.NamespaceDeclaration( 253SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithTrailingTrivia(fileScopedNamespace.SemicolonToken.TrailingTrivia), 257SyntaxFactory.Token(SyntaxKind.CloseBraceToken),

23using static SyntaxFactory;

25using static SyntaxFactory;

17using static SyntaxFactory;

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

31=> SyntaxFactory.ParseExpression(text);

320return SyntaxFactory.Token( 371leadingTrivia = leadingTrivia.Add(SyntaxFactory.Whitespace(indentation)); 373return SyntaxFactory.Token(

150SyntaxFactory.EqualsValueClause(SyntaxFactory.IdentifierName(property.Identifier.WithoutTrivia()))) 151.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))); 212.WithInitializer(SyntaxFactory.ConstructorInitializer( 214SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( 215expressions.Select(SyntaxFactory.Argument))))); 278? SyntaxFactory.Identifier(result.Symbol.Name) 281return SyntaxFactory.Parameter( 291var recordKeyword = SyntaxFactory.Token(SyntaxKind.RecordKeyword); 339SyntaxFactory.Argument(SyntaxFactory.IdentifierName(prop.Name))); 342SyntaxFactory.PrimaryConstructorBaseType(baseRecord.Type.WithoutTrailingTrivia(), 343SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(inheritedPositionalParams)) 375? SyntaxFactory.Token(SyntaxKind.SemicolonToken) 381? SyntaxFactory.Token(SyntaxKind.OpenBraceToken) 384? SyntaxFactory.Token(SyntaxKind.CloseBraceToken) 395return SyntaxFactory.RecordDeclaration( 404: typeDeclaration.Keyword.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 406typeDeclaration.Identifier.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 407typeDeclaration.TypeParameterList?.WithTrailingTrivia(SyntaxFactory.ElasticMarker), 408SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(propertiesToAddAsParams)) 434return SyntaxFactory.List<AttributeListSyntax>(); 437return SyntaxFactory.List(result.Declaration.AttributeLists.SelectAsArray(attributeList => 443.WithTarget(SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.PropertyKeyword))) 536return SyntaxFactory.ObjectCreationExpression( 539SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(updatedExpressions 540.Select(expression => SyntaxFactory.Argument(expression.WithoutTrivia())))), 599return SyntaxFactory.TriviaList(classTrivia.Concat(propertyNonDocComments).Select(trivia => trivia.AsElastic())); 629newClassDocComment = SyntaxFactory.DocumentationCommentTrivia( 634SyntaxFactory.List(propertyParamComments.Skip(1) 635.Prepend(SyntaxFactory.XmlText(SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false) 636.WithLeadingTrivia(SyntaxFactory.DocumentationCommentExterior("/**")) 638.Append(SyntaxFactory.XmlText(SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false)))), 639SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken) 640.WithTrailingTrivia(SyntaxFactory.DocumentationCommentExterior("*/"), SyntaxFactory.ElasticCarriageReturnLineFeed)); 646newClassDocComment = SyntaxFactory.DocumentationCommentTrivia( 648SyntaxFactory.List(propertyParamComments.Skip(1) 649.Prepend(SyntaxFactory.XmlText(SyntaxFactory.XmlTextLiteral(" ").WithLeadingTrivia(exteriorTrivia))))) 650.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed); 658return SyntaxFactory.TriviaList(classTrivia 661.Append(SyntaxFactory.Trivia(newClassDocComment)) 667return SyntaxFactory.TriviaList(classTrivia 668.Replace(classDocComment.Value, SyntaxFactory.Trivia(newClassDocComment)) 740yield return SyntaxFactory.XmlText( 741SyntaxFactory.XmlTextNewLine(lineFormattingOptions.NewLine, continueXmlDocumentationComment: false), 742SyntaxFactory.XmlTextLiteral(" ").WithLeadingTrivia(exteriorTrivia)); 747yield return SyntaxFactory.XmlParamElement(result.Symbol.Name, SyntaxFactory.XmlEmptyElement( 748SyntaxFactory.XmlName(DocumentationCommentXmlNames.InheritdocElementName))); 797return text.WithTextTokens(SyntaxFactory.TokenList(tokens)); 804yield return SyntaxFactory.XmlParamElement(result.Declaration.Identifier.ValueText, paramContent.AsArray());

410return SyntaxFactory.LiteralExpression(

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

42SyntaxFactory.NameEquals( 43SyntaxFactory.IdentifierName(name)));

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

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

122var newCloseParen = SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTriviaFrom(parenthesizedExpression.CloseParenToken);

78var yieldStatement = SyntaxFactory.YieldStatement(

23using static SyntaxFactory;

105var declarationPattern = SyntaxFactory.DeclarationPattern( 106GetPatternType().WithoutTrivia().WithTrailingTrivia(SyntaxFactory.ElasticMarker), 107SyntaxFactory.SingleVariableDesignation(newIdentifier)); 166var isPatternExpression = SyntaxFactory.IsPatternExpression(asExpression.Left, declarationPattern); 176SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), isPatternExpression.Pattern)); 180return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, isPatternExpression.Parenthesize());

102SyntaxFactory.ParseTypeName("Task")

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

26using static SyntaxFactory;

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

217(t, g) => t.WithTrailingTrivia(SyntaxFactory.ElasticSpace).WithoutAnnotations(Formatter.Annotation)); 245declarationExpression = SyntaxFactory.DeclarationExpression(explicitType, declarationExpression.Designation); 263? SyntaxFactory.IdentifierName("var") 283var designation = SyntaxFactory.SingleVariableDesignation(identifier.Identifier); 310newType = newType.WithAppendedTrailingTrivia(SyntaxFactory.ElasticSpace); 313return SyntaxFactory.DeclarationExpression(newType, designation); 330yield return SyntaxFactory.Space;

69var updatedCondition = SyntaxFactory.IsPatternExpression( 70isExpression.Left, SyntaxFactory.DeclarationPattern( 72SyntaxFactory.SingleVariableDesignation( 77.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

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

29private static readonly SyntaxToken s_asyncToken = SyntaxFactory.Token(SyntaxKind.AsyncKeyword); 158var result = SyntaxFactory.GenericName( 159SyntaxFactory.Identifier(type), 160SyntaxFactory.TypeArgumentList(SyntaxFactory.SingletonSeparatedList(typeArgumentFrom.GetTypeArguments()[0].GenerateTypeSyntax()))); 185var result = SyntaxFactory.TokenList(s_asyncToken.WithLeadingTrivia(newReturnType.GetLeadingTrivia()));

66newReturnType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)).WithTriviaFrom(returnTypeSyntax);

75.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(forEach.GetLeadingTrivia())); 80.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(forEachDeconstruction.GetLeadingTrivia())); 85.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(usingStatement.GetLeadingTrivia())); 90.WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword).WithLeadingTrivia(localDeclaration.GetLeadingTrivia()));

16using static SyntaxFactory;

37var semicolonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken); 40var block = SyntaxFactory.Block(statement);

46=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

61return SyntaxFactory.BinaryExpression( 74SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

273SimpleLambdaExpressionSyntax simpleLambda => SyntaxFactory.SingletonSeparatedList(simpleLambda.Parameter),

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

40=> SyntaxFactory.Block(statements); 65var objectCreationNode = SyntaxFactory.ObjectCreationExpression( 77? SyntaxFactory.DiscardDesignation().WithTriviaFrom(node) 78: SyntaxFactory.SingleVariableDesignation(newName).WithTriviaFrom(node); 86? SyntaxFactory.DiscardPattern().WithTriviaFrom(node) 87: SyntaxFactory.DiscardDesignation(); 105return SyntaxFactory.TypePattern(declarationPattern.Type).WithTrailingTrivia(trailingTrivia); 115var objectCreationNode = SyntaxFactory.ObjectCreationExpression( 183SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, leftOfAssignment, rightOfAssignment)); 195return SyntaxFactory.BinaryExpression(mappedBinaryExpressionKind, leftOfAssignment, rightOfAssignment);

23using static SyntaxFactory;

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

78var commaToken = SyntaxFactory.Token(SyntaxKind.CommaToken) 91return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens); 112SyntaxFactory.ImplicitElementAccess(elementAccess.ArgumentList)); 127? SyntaxFactory.ParenthesizedExpression(expression) 131return SyntaxFactory.InitializerExpression( 133SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithoutTrivia(), 134SyntaxFactory.SeparatedList( 137SyntaxFactory.Token(SyntaxKind.CloseBraceToken).WithoutTrivia());

28=> SyntaxFactory.Token(kind); 33return SyntaxFactory.AssignmentExpression(assignmentOpKind, left, syntaxToken, right); 47=> SyntaxFactory.PostfixUnaryExpression(kind, operand); 50=> SyntaxFactory.PrefixUnaryExpression(kind, operand);

64var newAssignment = SyntaxFactory.AssignmentExpression( 67SyntaxFactory.Token(SyntaxKind.QuestionQuestionEqualsToken).WithTriviaFrom(assignment.OperatorToken), 110var compoundOperator = SyntaxFactory.Token(SyntaxKind.QuestionQuestionEqualsToken); 111var finalAssignment = SyntaxFactory.AssignmentExpression(

40=> variable.WithInitializer(SyntaxFactory.EqualsValueClause(value)); 55return block.WithStatements(SyntaxFactory.SingletonList(statement))

41return block.WithStatements(SyntaxFactory.SingletonList(statement))

17return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

124return SyntaxFactory.ForEachVariableStatement( 142return SyntaxFactory.ExpressionStatement( 143SyntaxFactory.AssignmentExpression( 163=> SyntaxFactory.DeclarationExpression( 164typeNode, SyntaxFactory.ParenthesizedVariableDesignation( 165SyntaxFactory.SeparatedList<VariableDesignationSyntax>(tupleType.TupleElements.Select( 166e => SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier(e.Name.EscapeIdentifier())))))); 169=> SyntaxFactory.TupleExpression( 171SyntaxFactory.SeparatedList<ArgumentSyntax>(new SyntaxNodeOrTokenList(typeNode.Elements.GetWithSeparators().Select(ConvertTupleTypeElementComponent))), 185return SyntaxFactory.Argument( 186SyntaxFactory.DeclarationExpression( 188SyntaxFactory.SingleVariableDesignation(node.Identifier)));

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

62return SyntaxFactory.ImplicitObjectCreationExpression( 64currentObjectCreation.ArgumentList ?? SyntaxFactory.ArgumentList(),

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

23using static SyntaxFactory;

16using static SyntaxFactory;

34private static readonly TypeSyntax s_objectType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword)); 215modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); 235? SyntaxFactory.ArrowExpressionClause(((LambdaExpressionSyntax)anonymousFunction).ArrowToken, expression) 242return SyntaxFactory.LocalFunctionStatement( 255: SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(delegateMethod.Parameters.Select(parameter => 256PromoteParameter(generator, SyntaxFactory.Parameter(parameter.Name.ToIdentifierToken()), parameter)))); 282return SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(simpleLambda.Parameter)); 313return argumentNode.WithNameColon(argumentNode.NameColon.WithName(SyntaxFactory.IdentifierName(newParameter.Identifier))); 324=> SyntaxFactory.EqualsValueClause(ExpressionGenerator.GenerateExpression(generator, parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));

20using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

50var newStatementList = SyntaxFactory.SingletonList(newInnerStatement); 63=> SyntaxFactory.ElementBindingExpression(argumentList);

73var commaToken = SyntaxFactory.Token(SyntaxKind.CommaToken) 86return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens);

27using static SyntaxFactory;

29using static SyntaxFactory;

24using static SyntaxFactory;

55var name = SyntaxFactory.ParseName(text, consumeFullText: false); 57var parameterList = SyntaxFactory.ParseParameterList(text, lengthOfParsedText, consumeFullText: false); 77var token = SyntaxFactory.ParseToken(text, lengthOfParsedText);

55var expression = SyntaxFactory.ParseExpression(expressionValue);

207if (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;

521=> SyntaxFactory.AreEquivalent(left, right); 526if (SyntaxFactory.AreEquivalent(left, right)) 836=> SyntaxFactory.CompilationUnit(); 2619return SyntaxFactory.AreEquivalent(oldTryStatement.Finally, newTryStatement.Finally) 2620&& SyntaxFactory.AreEquivalent(oldTryStatement.Catches, newTryStatement.Catches); 2624return SyntaxFactory.AreEquivalent(oldNode, newNode); 2712if (!SyntaxFactory.AreEquivalent(oldContainingStatementPart, newContainingStatementPart) && 2960return SyntaxFactory.AreEquivalent(oldCasePatternLabel.Pattern, newCasePatternLabel.Pattern) && 2965return SyntaxFactory.AreEquivalent(oldLabel, newLabel); 3079if (!SyntaxFactory.AreEquivalent(oldVariables[i], newVariables[i]))

719if (!SyntaxFactory.AreEquivalent(leftBody, rightBody, null)) 747return SyntaxFactory.AreEquivalent(left, right, ignoreChildFunction); 752return SyntaxFactory.AreEquivalent(left.Labels, right.Labels, null) 753&& SyntaxFactory.AreEquivalent(left.Statements, right.Statements, ignoreChildNode: HasLabel); 1508if (weightedDistance == ExactMatchDist && !SyntaxFactory.AreEquivalent(oldNode, newNode)) 1521if (SyntaxFactory.AreEquivalent(oldNode, newNode)) 1544Debug.Assert(!SyntaxFactory.AreEquivalent(leftToken, rightToken) || distance == ExactMatchDist); 1552Debug.Assert(!SyntaxFactory.AreEquivalent(leftNode, rightNode) || distance == ExactMatchDist); 1663=> SyntaxFactory.AreEquivalent(oldElement, newElement); 1671=> SyntaxFactory.AreEquivalent(oldElement, newElement);

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

55var endOfLineTrivia = SyntaxFactory.ElasticEndOfLine(options.NewLine); 98AddLeadingTrivia(blockSyntax.CloseBraceToken, SyntaxFactory.ElasticMarker)); 121AddLeadingTrivia(currentBlock.OpenBraceToken, SyntaxFactory.ElasticMarker)); 125AddLeadingTrivia(currentBlock.CloseBraceToken, SyntaxFactory.ElasticMarker));

52var newIdentifier = SyntaxFactory.Identifier( 53leading: SyntaxTriviaList.Create(SyntaxFactory.ElasticMarker), 57trailing: SyntaxTriviaList.Create(SyntaxFactory.ElasticMarker)) 76var modifiers = SpecializedCollections.SingletonEnumerable(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)) 80SyntaxFactory.TokenList(modifiers))

95var info = model.GetSpeculativeTypeInfo(SelectionResult.FinalSpan.Start, SyntaxFactory.ParseName(symbol.Name), SpeculativeBindingOption.BindAsExpression);

193var typeName = SyntaxFactory.ParseTypeName(typeParameter.Name); 219methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SpecializedCollections.SingletonEnumerable(SyntaxFactory.EndOfLine(newLine))); 224methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SpecializedCollections.SingletonEnumerable(SyntaxFactory.EndOfLine(newLine)));

105return SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxFactory.TriviaList(triviaList), SyntaxKind.SemicolonToken, SyntaxTriviaList.Create(SyntaxFactory.ElasticMarker))); 119SyntaxFactory.LocalDeclarationStatement( 121SyntaxFactory.VariableDeclaration( 123SyntaxFactory.SeparatedList(list)), 295return SyntaxFactory.Block(SyntaxFactory.List(_statementsOrMemberOrAccessorToInsert.Cast<StatementSyntax>())); 345_statementsOrMemberOrAccessorToInsert.Select(s => global ? SyntaxFactory.GlobalStatement((StatementSyntax)s) : (MemberDeclarationSyntax)s));

189? SyntaxFactory.IdentifierName(_methodName) 190: SyntaxFactory.GenericName(_methodName, SyntaxFactory.TypeArgumentList(CreateMethodCallTypeVariables())); 201typeVariables.Add(SyntaxFactory.ParseTypeName(methodTypeParameter.Name)); 204return SyntaxFactory.SeparatedList(typeVariables); 301return SpecializedCollections.SingletonEnumerable<StatementSyntax>(SyntaxFactory.CheckedStatement(kind, SyntaxFactory.Block(statements))); 306return SpecializedCollections.SingletonEnumerable<StatementSyntax>(SyntaxFactory.CheckedStatement(kind, block)); 309return SpecializedCollections.SingletonEnumerable<StatementSyntax>(SyntaxFactory.CheckedStatement(kind, SyntaxFactory.Block(statements))); 429result.Add(SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxFactory.TriviaList(triviaList), SyntaxKind.SemicolonToken, SyntaxTriviaList.Create(SyntaxFactory.ElasticMarker)))); 436result.Add(SyntaxFactory.LocalDeclarationStatement( 438SyntaxFactory.VariableDeclaration( 440SyntaxFactory.SeparatedList(list)), 489replacements.Add(declaration, SyntaxFactory.IdentifierName(designation.Identifier) 562return SyntaxFactory.AssignmentExpression( 564SyntaxFactory.IdentifierName(identifier), 597=> SyntaxFactory.Identifier(name); 602? SyntaxFactory.ReturnStatement() 603: SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName(identifierName)); 617var refOrOut = modifier == SyntaxKind.None ? default : SyntaxFactory.Token(modifier); 618arguments.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(argument.Name)).WithRefOrOutKeyword(refOrOut)); 622var invocation = SyntaxFactory.InvocationExpression(methodName, 623SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))); 639invocation = SyntaxFactory.InvocationExpression( 640SyntaxFactory.MemberAccessExpression( 643SyntaxFactory.IdentifierName(nameof(Task.ConfigureAwait))), 644SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList( 645SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression))))); 649return SyntaxFactory.AwaitExpression(invocation); 653=> SyntaxFactory.ExpressionStatement(CreateAssignmentExpression(identifier, rvalue)); 668? SyntaxFactory.Token(SyntaxKind.UsingKeyword) 671var equalsValueClause = initialValue == null ? null : SyntaxFactory.EqualsValueClause(value: initialValue); 673return SyntaxFactory.LocalDeclarationStatement( 674SyntaxFactory.VariableDeclaration(typeNode) 675.AddVariables(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variable.Name)) 719SpecializedCollections.SingletonEnumerable(SyntaxFactory.ElasticCarriageReturnLineFeed))); 726SpecializedCollections.SingletonEnumerable(SyntaxFactory.ElasticCarriageReturnLineFeed))); 741return SyntaxFactory.ReturnStatement(callSignature); 744return SyntaxFactory.ExpressionStatement(callSignature); 849return SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(scope, GenerateMethodNameFromUserPreference()));

52return SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName)); 112expression = SyntaxFactory.ArrayCreationExpression(typeSyntax as ArrayTypeSyntax, containingScope as InitializerExpressionSyntax); 122SyntaxFactory.ReturnStatement( 128SyntaxFactory.ExpressionStatement( 141return SyntaxFactory.CheckedExpression(kind, expression);

144SyntaxFactory.LocalDeclarationStatement( 145SyntaxFactory.VariableDeclaration(keyValuePair.Value.First().Declaration.Type, SyntaxFactory.SeparatedList(variables))); 260return ImmutableArray.Create<StatementSyntax>(SyntaxFactory.ReturnStatement(declaration.Declaration.Variables[0].Initializer.Value)); 295var variable = declaration.Declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(assignmentExpression.Right)); 300SyntaxFactory.SingletonSeparatedList(variable))));

106? SpecializedCollections.SingletonEnumerable(SyntaxFactory.ElasticMarker) 116? SpecializedCollections.SingletonEnumerable(SyntaxFactory.ElasticMarker)

47var qualifiedName = SyntaxFactory.QualifiedName(SyntaxFactory.ParseName(containerName), newName) 62.WithStaticKeyword(SyntaxFactory.Token(SyntaxKind.StaticKeyword))

28SyntaxFactory.CheckedStatement(SyntaxKind.UncheckedStatement, 29SyntaxFactory.Block(statements.OfType<StatementSyntax>())));

70identifierToken = SyntaxFactory.Token( 96identifierToken = SyntaxFactory.Token(

154var parsedType = SyntaxFactory.ParseTypeName(localText, startIndex, consumeFullText: false); 205var declarationStatement = SyntaxFactory.LocalDeclarationStatement( 206SyntaxFactory.VariableDeclaration( 208SyntaxFactory.SingletonSeparatedList( 209SyntaxFactory.VariableDeclarator(token, null, SyntaxFactory.EqualsValueClause(

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

51var newModifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.NewKeyword));

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

13using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

80.AddAccessorListAccessors(SyntaxFactory 82.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken))) 92propertyDeclaration.AccessorList.WithAccessors(SyntaxFactory.List(accessors))); 104.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

63var semicolonToken = TryGetSemicolonToken(functionDeclaration) ?? SyntaxFactory.Token(SyntaxKind.SemicolonToken);

43_ => SyntaxFactory.SingletonList<StatementSyntax>(declarationStatement), 55=> SyntaxFactory.UsingStatement( 56SyntaxFactory.Token(SyntaxKind.UsingKeyword).WithLeadingTrivia(declarationStatement.GetLeadingTrivia()), 57SyntaxFactory.Token(SyntaxKind.OpenParenToken), 60SyntaxFactory.Token(SyntaxKind.CloseParenToken).WithTrailingTrivia(declarationStatement.GetTrailingTrivia()), 61statement: SyntaxFactory.Block(statementsToSurround)); 79.WithUsingKeyword(SyntaxFactory.Token(declarationStatement.GetLeadingTrivia(), SyntaxKind.UsingKeyword, SyntaxFactory.TriviaList(SyntaxFactory.Space)));

26using static SyntaxFactory;

37? SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.ParseName(typeDisplayString), SyntaxFactory.IdentifierName(newNameToken)) 38: (ExpressionSyntax)SyntaxFactory.IdentifierName(newNameToken); 42var newFieldDeclaration = SyntaxFactory.FieldDeclaration( 45SyntaxFactory.VariableDeclaration( 47SyntaxFactory.SingletonSeparatedList( 48SyntaxFactory.VariableDeclarator( 51SyntaxFactory.EqualsValueClause(expression.WithoutTrivia()))))).WithAdditionalAnnotations(Formatter.Annotation); 165if (!SyntaxFactory.AreEquivalent(oldMembers[i], newMembers[i], topLevel: false)) 187return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword)); 191return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); 195return SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));

37var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken); 40? SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword)) 43var declarationStatement = SyntaxFactory.LocalDeclarationStatement( 45SyntaxFactory.VariableDeclaration( 47SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator( 50SyntaxFactory.EqualsValueClause(expression.WithoutTrivia()))))); 58declarationStatement = declarationStatement.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed); 109newBody = newBody.WithOpenBraceToken(newBody.OpenBraceToken.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed)) 174return SyntaxFactory.Block(declarationStatement, SyntaxFactory.ReturnStatement(rewrittenBody)); 191return SyntaxFactory.Block(declarationStatement); 204return SyntaxFactory.Block( 206SyntaxFactory.ExpressionStatement(rewrittenBody, SyntaxFactory.Token(SyntaxKind.SemicolonToken))); 233? SyntaxFactory.ReturnStatement(newExpression) 234: (StatementSyntax)SyntaxFactory.ExpressionStatement(newExpression); 236var newBody = SyntaxFactory.Block(declarationStatement, convertedStatement) 241newBody = newBody.WithOpenBraceToken(newBody.OpenBraceToken.WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed)) 253var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList( 254SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, body))); 258.TryWithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) 264.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) 270.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) 276.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)) 329SyntaxFactory.Block(root.GetCurrentNode(statement)).WithAdditionalAnnotations(Formatter.Annotation));

34var newLocalName = SyntaxFactory.IdentifierName(newLocalNameToken); 36var letClause = SyntaxFactory.LetClause(

62=> SyntaxFactory.Block(); 111SyntaxKind.ContinueStatement => SyntaxFactory.ContinueStatement(), 112SyntaxKind.BreakStatement => SyntaxFactory.BreakStatement(), 113SyntaxKind.ReturnStatement => SyntaxFactory.ReturnStatement(), 114SyntaxKind.YieldBreakStatement => SyntaxFactory.YieldStatement(SyntaxKind.YieldBreakStatement), 127? block.WithStatements(SyntaxFactory.List(statementArray)) 130: SyntaxFactory.Block(statementArray); 156? SyntaxFactory.Block(trueStatement) 163: SyntaxFactory.ElseClause(falseStatementOpt); 230return n.WithStatements(SyntaxFactory.List(statements)); 232return n.WithStatements(SyntaxFactory.List(statements)); 242: SyntaxFactory.SingletonList(ifBody);

151if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 156SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

96: (invocationExpression.Expression, SyntaxFactory.IdentifierName(nameof(Action.Invoke))); 99SyntaxFactory.ConditionalAccessExpression( 101SyntaxFactory.InvocationExpression( 102SyntaxFactory.MemberBindingExpression(invokeName), invocationExpression.ArgumentList))); 108newStatement = block.WithStatements(SyntaxFactory.SingletonList(newStatement)); 143: SyntaxFactory.IdentifierName(nameof(Action.Invoke)); 146SyntaxFactory.ConditionalAccessExpression( 148SyntaxFactory.InvocationExpression( 149SyntaxFactory.MemberBindingExpression(invokeName), invocationExpression.ArgumentList)));

18=> SyntaxFactory.PrefixUnaryExpression(

243if (!SyntaxFactory.AreEquivalent(sourceIdentifier, selectorIdentifier)) 366return oldTokens.SequenceEqual(newTokens, SyntaxFactory.AreEquivalent);

24using static SyntaxFactory;

42var regionTrivia = SyntaxFactory.RegionDirectiveTrivia(true) 43.WithTrailingTrivia(new[] { SyntaxFactory.Space, SyntaxFactory.PreprocessingMessage(assemblyInfo) }); 47SyntaxFactory.Trivia(regionTrivia), 48SyntaxFactory.CarriageReturnLineFeed, 49SyntaxFactory.Comment("// " + assemblyPath), 50SyntaxFactory.CarriageReturnLineFeed, 51SyntaxFactory.Trivia(SyntaxFactory.EndRegionDirectiveTrivia(true)), 52SyntaxFactory.CarriageReturnLineFeed, 53SyntaxFactory.CarriageReturnLineFeed); 142SyntaxFactory.Trivia(SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(keyword), isActive: enable)), 143SyntaxFactory.ElasticCarriageReturnLineFeed, 144SyntaxFactory.ElasticCarriageReturnLineFeed, 169return SyntaxFactory.List(builder); 212var result = type.WithMembers(SyntaxFactory.List(builder));

201var compilationUnitWithoutUsings = compilationUnit.WithUsings(SyntaxFactory.List(compilationUnit.Usings.Where(u => u.GlobalKeyword != default))); 368var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

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

34=> SyntaxFactory.ParseExpression(text);

99SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 102var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(accessor)); 129var property = SyntaxFactory.PropertyDeclaration( 138property = property.AddModifiers(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); 144var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getAccessor)); 158? SyntaxFactory.Identifier(propertyName) 209var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration); 248var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration); 301return SyntaxFactory.IdentifierName("value").WithTriviaFrom(node); 345var expression = SyntaxFactory.AssignmentExpression( 376newName = SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(propertyName));

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

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

132methodDeclaration = methodDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); 150return methodDeclaration.WithBody(SyntaxFactory.Block( 187methodDeclaration = methodDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); 217SyntaxFactory.Block( 251return SyntaxFactory.Trivia((StructuredTriviaSyntax)rewritten); 308var parameter = SyntaxFactory.CrefParameter(typeSyntax); 309parameterList = SyntaxFactory.CrefParameterList(SyntaxFactory.SingletonSeparatedList(parameter)); 313parameterList = SyntaxFactory.CrefParameterList(); 317var crefAttribute = SyntaxFactory.XmlCrefAttribute( 318SyntaxFactory.NameMemberCref(SyntaxFactory.IdentifierName(identifierToken), parameterList)); 347return SyntaxFactory.BinaryExpression(operatorKind, readExpression, parent.Right.Parenthesize());

337var newOperator = SyntaxFactory.Token(SyntaxKind.LessThanToken).WithTriviaFrom(outerBinary.OperatorToken); 347var newOperator = SyntaxFactory.Token(SyntaxKind.GreaterThanToken).WithTriviaFrom(outerBinary.OperatorToken); 372var newOperator = SyntaxFactory.Token(newOperatorKind).WithTriviaFrom(condition.OperatorToken); 373return SyntaxFactory.BinaryExpression(newExpressionKind, left, newOperator, right); 395var newOpToken = SyntaxFactory.Token(newKind).WithTriviaFrom(opToken);

156var newBracketedArgumentList = SyntaxFactory.ParseBracketedArgumentList(openBracket.Parent!.ToString()); 160var elementBinding = SyntaxFactory.ElementBindingExpression(newBracketedArgumentList); 161var conditionalAccessExpression = SyntaxFactory.ConditionalAccessExpression(expression, elementBinding); 171var elementAccessExpression = SyntaxFactory.ElementAccessExpression(expression, newBracketedArgumentList);

60modifiers = SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PublicKeyword)); 63return SyntaxFactory.PropertyDeclaration( 69accessorList: SyntaxFactory.AccessorList(new SyntaxList<AccessorDeclarationSyntax>(accessors.Where(a => a is not null)!)));

102originalTypeDeclaration.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

90blockStatement = blockStatement!.WithCloseBraceToken(blockStatement.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

68var elseClause = SyntaxFactory.ElseClause(SyntaxFactory.Block()); 112blockStatement = blockStatement.WithCloseBraceToken(blockStatement.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

41var varIdentifier = SyntaxFactory.IdentifierName("var"); 47? SyntaxFactory.IdentifierName("collection") 48: SyntaxFactory.IdentifierName(enumerationSymbol.Name); 51var foreachLoopSyntax = SyntaxFactory.ForEachStatement(varIdentifier, itemString, collectionIdentifier, SyntaxFactory.Block()); 99blockStatement = blockStatement.WithCloseBraceToken(blockStatement.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

76blockStatement = blockStatement.WithCloseBraceToken(blockStatement.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

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

76blockStatement = blockStatement.WithCloseBraceToken(blockStatement.CloseBraceToken.WithPrependedLeadingTrivia(SyntaxFactory.SyntaxTrivia(SyntaxKind.WhitespaceTrivia, indentationString)));

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

113return ifStatement.WithStatement(SyntaxFactory.Block((StatementSyntax)statement)); 140var newIfStatement = ifStatement.WithElse(SyntaxFactory.ElseClause(newElseIfStatement)); 147newIfStatement = newIfStatement.WithStatement(SyntaxFactory.Block(newIfStatement.Statement));

67var leftExpression = SyntaxFactory.InterpolatedStringExpression( 69SyntaxFactory.List(beforeSplitContents), 70SyntaxFactory.Token(SyntaxKind.InterpolatedStringEndToken) 71.WithTrailingTrivia(SyntaxFactory.ElasticSpace)); 73var rightExpression = SyntaxFactory.InterpolatedStringExpression( 74SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), 75SyntaxFactory.List(afterSplitContents), 78return SyntaxFactory.BinaryExpression( 88return SyntaxFactory.InterpolatedStringText( 89SyntaxFactory.Token(

57var firstToken = SyntaxFactory.Token( 62trailing: SyntaxFactory.TriviaList(SyntaxFactory.ElasticSpace)); 64var secondToken = SyntaxFactory.Token( 71var leftExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, firstToken); 72var rightExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, secondToken); 74return SyntaxFactory.BinaryExpression(

35PlusNewLineToken = SyntaxFactory.Token( 38SyntaxFactory.TriviaList(SyntaxFactory.EndOfLine( 128var newRightExpression = rightExpression.WithLeadingTrivia(SyntaxFactory.ElasticWhitespace(indentString));

52.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.None)); 58var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration) 59.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 67var modifiers = SyntaxFactory.TokenList( 77updatedProperty = updatedProperty.WithInitializer(SyntaxFactory.EqualsValueClause(fieldInitializer)) 78.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 167var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration) 168.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 169return SyntaxFactory.AccessorList(SyntaxFactory.List(Enumerable.Repeat(getter, 1))); 172return accessorList.WithAccessors(SyntaxFactory.List(GetAccessors(accessorList.Accessors))); 181.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));

185newDeclaration = SyntaxFactory.DeclarationExpression(typeName, designation); 198builder.Add(SyntaxFactory.Argument(newDeclaration)); 201var separatorBuilder = ArrayBuilder<SyntaxToken>.GetInstance(builder.Count - 1, SyntaxFactory.Token(leading: default, SyntaxKind.CommaToken, trailing: default)); 203return SyntaxFactory.TupleExpression( 204SyntaxFactory.Token(SyntaxKind.OpenParenToken).WithTrailingTrivia(), 205SyntaxFactory.SeparatedList(builder.ToImmutable(), separatorBuilder.ToImmutableAndFree()), 206SyntaxFactory.Token(SyntaxKind.CloseParenToken))

44updatedDecl = updatedDecl.WithArrowToken(updatedDecl.ArrowToken.WithTrailingTrivia(SyntaxFactory.ElasticSpace)); 67return currentDeclaration.WithBody(SyntaxFactory.Block( 68SyntaxFactory.Token(SyntaxKind.OpenBraceToken).WithAppendedTrailingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed), 69SyntaxFactory.SingletonList(statement), 70SyntaxFactory.Token(SyntaxKind.CloseBraceToken)));

160arrowExpression = SyntaxFactory.ArrowExpressionClause(getAccessor.ExpressionBody.Expression); 180SyntaxFactory.Token(SyntaxKind.SemicolonToken), false, block: out _) != true) 296var accessor = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration); 302return WithAccessorList(declaration, SyntaxFactory.AccessorList( 303SyntaxFactory.SingletonList(accessor)));

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

10using static SyntaxFactory;

69=> argumentList.WithArguments(SyntaxFactory.SeparatedList(namedArguments, separators)); 72=> argument.WithNameColon(SyntaxFactory.NameColon(name.ToIdentifierName())); 89=> argumentList.WithArguments(SyntaxFactory.SeparatedList(namedArguments, separators)); 92=> argument.WithNameColon(SyntaxFactory.NameColon(name.ToIdentifierName()));

195var newLocalName = SyntaxFactory.Identifier(localName) 197var isPattern = SyntaxFactory.IsPatternExpression( 199SyntaxFactory.DeclarationPattern((TypeSyntax)isExpression.Right.WithTrailingTrivia(SyntaxFactory.Space), 200SyntaxFactory.SingleVariableDesignation(newLocalName))).WithTriviaFrom(isExpression); 205var localReference = SyntaxFactory.IdentifierName(localName); 255if (SyntaxFactory.AreEquivalent(castExpression.Type, type) && 256SyntaxFactory.AreEquivalent(castExpression.Expression.WalkDownParentheses(), expr))

29using static SyntaxFactory;

176arguments.Add(SyntaxFactory.Argument(stringLiteral)); 183return argumentList.WithArguments(SyntaxFactory.SeparatedList<ArgumentSyntax>(arguments)); 193var stringLiteral = SyntaxFactory.LiteralExpression(SyntaxKind.Utf8StringLiteralExpression, 194SyntaxFactory.Token( 208return SyntaxFactory.InvocationExpression( 209SyntaxFactory.MemberAccessExpression( 212SyntaxFactory.IdentifierName(nameof(ReadOnlySpan<byte>.ToArray))))

608var speculatedBlock = (BlockSyntax)SyntaxFactory.ParseStatement(@"

1217.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>(SyntaxFactory.NodeOrTokenList(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(10))))); 2303.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>(SyntaxFactory.NodeOrTokenList(SyntaxFactory.ParseExpression("y switch { int z => 42 }")))); 2364.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>(SyntaxFactory.NodeOrTokenList(SyntaxFactory.ParseExpression("y switch { int z => 42 }")))); 2832.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>(SyntaxFactory.NodeOrTokenList(SyntaxFactory.ParseExpression("y switch { int z => 42 }"))));

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);

528new[] { SyntaxFactory.ParseSyntaxTree("public class C {}") }, 1116new[] { SyntaxFactory.ParseSyntaxTree(source) },

53var tree = SyntaxFactory.ParseSyntaxTree(source); 82var tree = SyntaxFactory.ParseSyntaxTree(source); 3113syntaxTree: SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script),

25var tree = SyntaxFactory.ParseSyntaxTree(" class C { void M() { await X() on ");

2907var tree = SyntaxFactory.ParseSyntaxTree(@" 2934var tree = SyntaxFactory.ParseSyntaxTree(@" 2962var tree = SyntaxFactory.ParseSyntaxTree(@"

9379var stmt = SyntaxFactory.ParseStatement(text);

4975var alias1 = SyntaxFactory.IdentifierName("alias1");

4160var newExpression = SyntaxFactory.ParseExpression("new()"); 4187var modifiedNode = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement("M(new());", options: ImplicitObjectCreationTestOptions);

3123var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"

586SyntaxFactory.IdentifierName(name), 596SyntaxFactory.IdentifierName(name),

533Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 534Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + " ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 535Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + "{").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 536Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + "{ ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 537Assert.True(SyntaxFactory.ParseSyntaxTree(source + verbat).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 538Assert.True(SyntaxFactory.ParseSyntaxTree(source + verbat + " ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 539Assert.True(SyntaxFactory.ParseSyntaxTree(source + verbat + "{").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 540Assert.True(SyntaxFactory.ParseSyntaxTree(source + verbat + "{ ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 558Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 576Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 595Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 1491Assert.True(SyntaxFactory.ParseSyntaxTree(text).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error));

833var tree = SyntaxFactory.ParseSyntaxTree(source); 942SyntaxFactory.ParseExpression("Goo(() => () => { var x = null; return x; })"), // cast removed 1165var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular9); 1198var tree = SyntaxFactory.ParseSyntaxTree(source); 1230var tree = SyntaxFactory.ParseSyntaxTree(source); 2990var tree = SyntaxFactory.ParseSyntaxTree(source); 3032var tree = SyntaxFactory.ParseSyntaxTree(source); 3969var newTree = SyntaxFactory.ParseSyntaxTree(source + " "); 8050var newStmt = SyntaxFactory.ParseStatement("var lam = (int b = M1(4)) => b;"); 8051var newMethod = m2Syntax.WithBody(SyntaxFactory.Block(newStmt));

343var tree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Regular9); 347var newTree = SyntaxFactory.ParseSyntaxTree(text + " "); 391var tree = SyntaxFactory.ParseSyntaxTree(text); 403var newTree = SyntaxFactory.ParseSyntaxTree(text + " "); 438var tree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Regular9); 443var newTree = SyntaxFactory.ParseSyntaxTree(text + " ", options: TestOptions.Regular9); 1679var tree = SyntaxFactory.ParseSyntaxTree(@" 1889var tree = SyntaxFactory.ParseSyntaxTree(@" 1945var tree = SyntaxFactory.ParseSyntaxTree(@" 7278=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 7373=> SyntaxFactory.ParseCompilationUnit($@"{source};", options: parseOptions).DescendantNodes().OfType<InvocationExpressionSyntax>().Single(); 7376=> SyntaxFactory.ParseCompilationUnit($@"{source};", options: parseOptions).DescendantNodes().OfType<IdentifierNameSyntax>().Single(); 7450=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 7503=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 8859=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 9367=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 9685=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single();

1505var node2 = (ExpressionSyntax)SyntaxFactory.SyntaxTree(node).GetRoot();

4075var typeSyntax = SyntaxFactory.ParseTypeName("nuint");

2229var type = SyntaxFactory.ParseTypeName(typeName);

5780var source4 = SyntaxFactory.ParseSyntaxTree(@" 7762SyntaxFactory.SeparatedList<ExpressionSyntax>( 7763new[] { SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)) }), 110059TypeSyntax type = SyntaxFactory.ParseTypeName( 110096TypeSyntax type = SyntaxFactory.ParseTypeName( 110121TypeSyntax type = SyntaxFactory.ParseTypeName( 110146TypeSyntax type = SyntaxFactory.ParseTypeName( 110175TypeSyntax type = SyntaxFactory.ParseTypeName( 110202TypeSyntax type = SyntaxFactory.ParseTypeName( 110230TypeSyntax type = SyntaxFactory.ParseTypeName( 110258TypeSyntax type = SyntaxFactory.ParseTypeName( 110284TypeSyntax type = SyntaxFactory.ParseTypeName( 110322TypeSyntax type = SyntaxFactory.ParseTypeName( 110347TypeSyntax type = SyntaxFactory.ParseTypeName( 110372TypeSyntax type = SyntaxFactory.ParseTypeName( 110401TypeSyntax type = SyntaxFactory.ParseTypeName( 110428TypeSyntax type = SyntaxFactory.ParseTypeName( 110456TypeSyntax type = SyntaxFactory.ParseTypeName( 110484TypeSyntax type = SyntaxFactory.ParseTypeName(

3458ArgumentListSyntax arguments = SyntaxFactory.ParseArgumentList(@"(TakeOutParam(o, out int x1) && x1 >= 5)"); 3459var initializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, arguments); 3499ArgumentListSyntax arguments = SyntaxFactory.ParseArgumentList(@"(TakeOutParam(o, out int x1) && x1 >= 5)"); 3500var initializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, arguments); 4000var statement = (DoStatementSyntax)SyntaxFactory.ParseStatement(@" 5106var statement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement(@" 8800var statement = (IfStatementSyntax)SyntaxFactory.ParseStatement(@" 9639var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@" 10207var statement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement(@" 10856var statement = (LockStatementSyntax)SyntaxFactory.ParseStatement(@" 13336var statement = (ReturnStatementSyntax)SyntaxFactory.ParseStatement(@" 13735var statement = (SwitchStatementSyntax)SyntaxFactory.ParseStatement(@" 15256var statement = (ThrowStatementSyntax)SyntaxFactory.ParseStatement(@" 16534var statement = (WhileStatementSyntax)SyntaxFactory.ParseStatement(@" 17093var statement = (YieldStatementSyntax)SyntaxFactory.ParseStatement(@" 17529var statement = (LabeledStatementSyntax)SyntaxFactory.ParseStatement(@" 21281var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@" 32446var node0 = SyntaxFactory.ParseCompilationUnit(source); 32448var decl = SyntaxFactory.DeclarationExpression( 32449type: SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("var")), 32450designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("x1"))); 34274.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34275SyntaxFactory.NodeOrTokenList( 34276SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34277SyntaxFactory.Token(SyntaxKind.CommaToken), 34278SyntaxFactory.ParseExpression($"x{i + 1}") 34488.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34489SyntaxFactory.NodeOrTokenList( 34490SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34491SyntaxFactory.Token(SyntaxKind.CommaToken), 34492SyntaxFactory.ParseExpression($"x{i + 1}") 35606var statementAfter = SyntaxFactory.ParseStatement(@"G(out _);");

2056speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 2208speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

2300var info = semanticModel.GetSpeculativeTypeInfo(selectExpression.SpanStart, SyntaxFactory.ParseExpression("x"), SpeculativeBindingOption.BindAsExpression); 3414var queryStatement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(speculatedSource); 3458var queryStatement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(speculatedSource); 3505var queryStatement = SyntaxFactory.ParseStatement(speculatedSource); 3544var queryStatement = SyntaxFactory.ParseStatement(speculatedSource); 3588var queryStatement = SyntaxFactory.ParseStatement(speculatedSource);

559Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 560Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + " ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 561Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + "{").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 562Assert.True(SyntaxFactory.ParseSyntaxTree(source + normal + "{ ").GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 580Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 598Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 617Assert.True(SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error)); 1163Assert.True(SyntaxFactory.ParseSyntaxTree(text).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error));

10653AssertEx.AssertEqualToleratingWhitespaceDifferences(expected, SyntaxFactory.TypeDeclaration(SyntaxKind.RecordStructDeclaration, "Point").NormalizeWhitespace().ToString());

22287speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 22439speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

23var tree = SyntaxFactory.ParseSyntaxTree(@"

539var tree = SyntaxFactory.ParseSyntaxTree(@" 1047var tree = SyntaxFactory.ParseSyntaxTree(@"

263var tree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 286var tree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 298var submission = CSharpCompilation.CreateScriptCompilation("test", syntaxTree: SyntaxFactory.ParseSyntaxTree("1", options: TestOptions.Script), returnType: typeof(int)); 365var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 396var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 443var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script); 485var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script.WithLanguageVersion(LanguageVersion.CSharp6)); 1179var compilationUnit = CSharp.SyntaxFactory.ParseCompilationUnit(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1207syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1216syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1225syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1237syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1249syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1267var compilationUnit = CSharp.SyntaxFactory.ParseCompilationUnit("\nSystem.Console.WriteLine(1);", options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1269var syntaxTree2 = SyntaxFactory.ParseSyntaxTree("System.Console.WriteLine(2);", options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1306var compilationUnit = CSharp.SyntaxFactory.ParseCompilationUnit(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1336syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script)); 1351syntaxTree = SyntaxFactory.ParseSyntaxTree(code, options: new CSharp.CSharpParseOptions(kind: SourceCodeKind.Script));

1387new[] { SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script) });

75var exp = SyntaxFactory.ParseExpression("new A().M()._num"); 91var statement = SyntaxFactory.ParseStatement("var goo = new A().M();"); 119var tree = SyntaxFactory.ParseSyntaxTree(source); 126SyntaxFactory.ParseExpression("a._p"), 174var speculativeInvocation = SyntaxFactory.ParseExpression("new A().InternalExtension(67)"); 203var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"

1147var syntaxTree = SyntaxFactory.ParseSyntaxTree(source); 2419syntaxTree: SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Script),

26var node = SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("Blah")); 27var tree = SyntaxFactory.SyntaxTree(node); 34var node = SyntaxFactory.CatchClause(SyntaxFactory.CatchDeclaration(SyntaxFactory.ParseTypeName(typeof(InvalidOperationException).Name)), null, SyntaxFactory.Block()); 42var tree = SyntaxFactory.ParseSyntaxTree(@"class Program { static void Main() { System.Console.WriteLine(""Wah""); } }"); 50var tree = SyntaxFactory.SyntaxTree(SyntaxFactory.FromClause("Nay", SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(823)))); 60var arbitraryTree = SyntaxFactory.SyntaxTree(SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Wooh"))); 61var parsedTree = SyntaxFactory.ParseSyntaxTree(""); 71var tree = SyntaxFactory.SyntaxTree( 72SyntaxFactory.LetClause("Blah", SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(54))), 74SyntaxFactory.IsCompleteSubmission(tree); 80var node = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)); 88var node = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)); 96var node = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, 97SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3))); 107var tree = SyntaxFactory.ParseSyntaxTree("class TheClass { }");

2484var expressionSyntax = SyntaxFactory.ParseExpression("default");

9692var nodeToSpeculate = SyntaxFactory.ParseStatement("int y = x;");

3432var tree = SyntaxFactory.ParseSyntaxTree(@" 3528var tree = SyntaxFactory.ParseSyntaxTree(code, TestOptions.Regular); 4459model.GetSpeculativeTypeInfo(syntax.SpanStart, SyntaxFactory.ParseTypeName("S*"), SpeculativeBindingOption.BindAsTypeOrNamespace);

48var tree = SyntaxFactory.ParseSyntaxTree(@" 71var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l;}"); 91var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l;}"); 113var tree = SyntaxFactory.ParseSyntaxTree(@" 139var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l; }"); 166var tree = SyntaxFactory.ParseSyntaxTree(@" class C { long _f = 0l; }"); 167var newTree = SyntaxFactory.ParseSyntaxTree(@" class D { long _f = 0l; }"); 192var tree = SyntaxFactory.ParseSyntaxTree(@" class C { long _f = 0l; }"); 354SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 387new[] { SyntaxFactory.ParseSyntaxTree("class C { static void Main() {} }") }, 615syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree("public class C {}") }, 623syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 634syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 647syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 683syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree("public class C {}", options: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp6)) }, 691syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 702syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 715syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 784SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 785SyntaxTree withErrorTree = SyntaxFactory.ParseSyntaxTree(s2); 786SyntaxTree withErrorTree1 = SyntaxFactory.ParseSyntaxTree(s3); 787SyntaxTree withErrorTreeVB = SyntaxFactory.ParseSyntaxTree(s4); 788SyntaxTree withExpressionRootTree = SyntaxFactory.ParseExpression(s3).SyntaxTree; 789var withWarning = SyntaxFactory.ParseSyntaxTree(s5); 792var comp = CSharpCompilation.Create("Compilation", syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(s1) }, options: TestOptions.ReleaseDll); 806Assert.False(comp.SyntaxTrees.Contains(SyntaxFactory.ParseSyntaxTree(s1))); 808comp = comp.AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(s1)); 812comp = comp.ReplaceSyntaxTree(t1, SyntaxFactory.ParseSyntaxTree(s1)); 826Assert.Throws<ArgumentException>(() => comp = comp.RemoveSyntaxTrees(SyntaxFactory.ParseSyntaxTree(s1))); 841SyntaxTree t4 = SyntaxFactory.ParseSyntaxTree("Using System;"); 842SyntaxTree t5 = SyntaxFactory.ParseSyntaxTree("Usingsssssssssssss System;"); 843SyntaxTree t6 = SyntaxFactory.ParseSyntaxTree("Import System;"); 930SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 931SyntaxTree t2 = SyntaxFactory.ParseSyntaxTree(s2); 932SyntaxTree t3 = SyntaxFactory.ParseSyntaxTree(s3); 1178var comp1 = CSharpCompilation.Create("Test1", new[] { SyntaxFactory.ParseSyntaxTree(text1) }); 1179var comp2 = CSharpCompilation.Create("Test2", new[] { SyntaxFactory.ParseSyntaxTree(text1) }); 1192new[] { SyntaxFactory.ParseSyntaxTree(text1) }, 1482SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1490Assert.Throws<ArgumentException>(() => comp.ReplaceSyntaxTree(newTree: SyntaxFactory.ParseSyntaxTree("Using System;"), oldTree: t1)); 1542SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1546comp = comp.ReplaceSyntaxTree(newTree: SyntaxFactory.ParseSyntaxTree("Using System;"), oldTree: t1); 1556SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1565SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree("Using Goo;"); 1620SyntaxTree t4 = SyntaxFactory.ParseSyntaxTree(s1); 2380var tree1 = SyntaxFactory.ParseSyntaxTree("", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)); 2381var tree2 = SyntaxFactory.ParseSyntaxTree("", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)); 2382var tree3 = SyntaxFactory.ParseSyntaxTree("", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));

3786var syntax = SyntaxFactory.ParseExpression(" C.M"); //Leading trivia was significant for triggering an assert before the fix. 3819var syntax = SyntaxFactory.ParseExpression(" C.M"); //Leading trivia was significant for triggering an assert before the fix. 3913var syntax = SyntaxFactory.ParseExpression(" a.P"); //Leading trivia was significant for triggering an assert before the fix. 3953var syntax = SyntaxFactory.ParseExpression(" a.P"); //Leading trivia was significant for triggering an assert before the fix. 4066var speculativeSyntax = SyntaxFactory.ParseExpression("fields.Any((field => field.IsStatic))"); //cast removed 4322var speculativeSyntax = SyntaxFactory.ParseExpression("new List { 1, 2 }"); 4876var newSyntax = SyntaxFactory.ParseExpression("Instance.GetList().OfType<D>().Any()"); 6012var syntax = SyntaxFactory.ParseExpression("base");

195var info = model.GetSpeculativeSymbolInfo(position, SyntaxFactory.IdentifierName("Console"), SpeculativeBindingOption.BindAsTypeOrNamespace);

1019new[] { SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Regular) },

729TypeSyntax speculate = SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("A")); 1363var newSyntax = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer); 1392var newSyntax = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer); 1420var equalsValue = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression(@"(string)""Hello""")); 1462var newEqualsValue = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("(short)0")); 1510var newEqualsValue = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("(short)0")); 1557var newEqualsValue = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("E.B | E.A")); 1598var newEqualsValue = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("(short)0")); 1679var newExpressionBody = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(@"(string)""Hello""")); 1766var statement = (BlockSyntax)SyntaxFactory.ParseStatement(@" 1832var statement = SyntaxFactory.ParseStatement(@"int z = 0;"); 1847statement = SyntaxFactory.ParseStatement(@"string y = null;"); 1873var labeledStatement = SyntaxFactory.ParseStatement(@"label: y++;"); 1905var switchStatement = (SwitchStatementSyntax)SyntaxFactory.ParseStatement(@" 1949var speculatedStatement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@"Func<int, int> var = (z) => x + z;"); 1982var statement = (ForEachStatementSyntax)SyntaxFactory.ParseStatement(@" 2029var newSyntax = SyntaxFactory.EqualsValueClause( 2030SyntaxFactory.ParseExpression("this.y")); 2074var newSyntax = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer); 2091var newArgument = SyntaxFactory.ParseExpression("1"); 2108newArgument = SyntaxFactory.ParseExpression("(string) 1"); 2143var newSyntax = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer); 2191var speculatedStatement = statement.ReplaceNode(initializer.Value, SyntaxFactory.ParseExpression("0")); 2225var speculatedStatement = statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("0")); 2233var newSpeculatedStatement = statement.ReplaceNode(expression, SyntaxFactory.ParseExpression("1.1")); 2238newSpeculatedStatement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@"int z = 0;"); 2261var unsafeStatement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement("int *p = &x;"); 2317var speculativeSyntax = SyntaxFactory.ParseStatement("return default(C);"); 2338var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@" 2433var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@" 2475var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@" 2520var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@" 2566var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ int z = 0; }"); 2583blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ string y = null; }"); 2597blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ var y = x; }"); 2637var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ label: y++; }"); 2674var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ Func<int, int> var = (z) => x + z; }"); 2765var blockStatement = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ 2800var speculatedUsingExpression = SyntaxFactory.ParseName("System.Collections"); 2815var speculatedUsingExpression = SyntaxFactory.ParseName("System.ArgumentException"); 2835var speculatedTypeExpression = SyntaxFactory.ParseName("System.ArgumentException"); 2866var speculatedTypeExpression = SyntaxFactory.ParseName("System.ArgumentException"); 2895var speculatedAliasName = SyntaxFactory.ParseName("A"); 2928var speculatedCref = (TypeCrefSyntax)SyntaxFactory.ParseCref("object"); 2968var speculatedCref = (NameMemberCrefSyntax)SyntaxFactory.ParseCref("A"); 3013var speculatedCref = (QualifiedCrefSyntax)SyntaxFactory.ParseCref("A.B"); 3043speculatedCref = (QualifiedCrefSyntax)SyntaxFactory.ParseCref("A.M"); 3090var speculatedCref = (TypeCrefSyntax)SyntaxFactory.ParseCref("object"); 3158var yieldStatement = (YieldStatementSyntax)SyntaxFactory.ParseStatement("yield return 1;"); 3193var yieldStatement = (YieldStatementSyntax)SyntaxFactory.ParseStatement("yield return 1;"); 3223var typeSyntax = SyntaxFactory.ParseTypeName("System.Collections.Generic.IEnumerable<C[]>"); 3264var statementSyntax = SyntaxFactory.ParseStatement("TakesOut(out int x);"); 3305var statementSyntax = SyntaxFactory.ParseStatement("TakesOut(out int x);"); 3346var statementSyntax = SyntaxFactory.ParseExpression("TakesOut(out int x)"); 3380var statementSyntax = SyntaxFactory.ParseStatement("{ TakesOut(out int x); }"); 3422var statementSyntax = SyntaxFactory.ParseStatement("Method(o is string s);"); 3463var statementSyntax = SyntaxFactory.ParseStatement("Method(o is string s);"); 3504var statementSyntax = SyntaxFactory.ParseExpression("Method(o is string s)"); 3557return SyntaxFactory.ParseCompilationUnit(source + " class X {}").Members.First().AsTypeDeclarationSyntax().AttributeLists.First().Attributes.First(); 3585var attributeSyntax = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Category")); 3620var speculatedName = (GenericNameSyntax)SyntaxFactory.GenericName("List{T}"); 3788var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 4328var typeSyntax = SyntaxFactory.ParseTypeName("dynamic"); 4428var replacementIfStatement = (IfStatementSyntax)SyntaxFactory.ParseStatement(replacementSource);

2750var tree = SyntaxFactory.ParseSyntaxTree(test, options: new CSharpParseOptions(languageVersion: LanguageVersion.CSharp6)); 3104new[] { SyntaxFactory.ParseSyntaxTree(text2) }, 3959var tree2 = SyntaxFactory.ParseSyntaxTree(@" 4006symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<T>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4012symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<int>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4018symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4024symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("B<U>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4030symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("B<int>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4036symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("B<>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4042symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<>.B<>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4048symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<>.B<U>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4053symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<T>.B<>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4059symbolInfo = model.GetSpeculativeSymbolInfo(typeofArgPosition, SyntaxFactory.ParseTypeName("A<T>.B<U>"), SpeculativeBindingOption.BindAsTypeOrNamespace); 4089var expression = SyntaxFactory.ParseExpression("B"); 4106return SyntaxFactory.ParseCompilationUnit(source + " class X {}").Members.First().AsTypeDeclarationSyntax().AttributeLists.First().Attributes.First(); 4369var attr8 = SyntaxFactory.ParseCompilationUnit(@"[assembly: O(""hello"")]").AttributeLists.First().Attributes.First();

57var tree1 = SyntaxFactory.ParseSyntaxTree(text1); 58var tree2 = SyntaxFactory.ParseSyntaxTree(text2); 226var tree1 = SyntaxFactory.ParseSyntaxTree(text1); 227var tree2 = SyntaxFactory.ParseSyntaxTree(text2); 262new[] { SyntaxFactory.ParseSyntaxTree(code) }, 271var underlyingTree = SyntaxFactory.ParseSyntaxTree(@" 280var foreignType = SyntaxFactory.ParseSyntaxTree(@" 318var underlyingTree = SyntaxFactory.ParseSyntaxTree(@" 327var foreignType = SyntaxFactory.ParseSyntaxTree(@"

6285var speculatedName = SyntaxFactory.ParseName("b"); 6342var accessorName = SyntaxFactory.ParseName(accessor.Name); 6357var inheritedTypeName = SyntaxFactory.ParseName(inheritedType.Name);

759var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 760var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 887var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 888var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 925var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularWithDocumentationComments); 962var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 963var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1011var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1012var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1062var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1063var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1112var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1113var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1167var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1168var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1215var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1216var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1270var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1271var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1327var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1328var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1390var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1391var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1453var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1454var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 2537var newLeadingTrivia = SyntaxFactory.ParseToken("/** " + (_count++) + " */1)").LeadingTrivia; 4628var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 4629var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments);

2715var tree = SyntaxFactory.ParseSyntaxTree(text, TestOptions.Script); 6289var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6332var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6363var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6427var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6458var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6521var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6554var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6599var srcTree = SyntaxFactory.ParseSyntaxTree(@"

1478var expr1 = SyntaxFactory.ParseExpression("new { x = 1, y" + i.ToString() + " = \"---\" }"); 1637var tree = SyntaxFactory.ParseSyntaxTree(source); 1678var tree = SyntaxFactory.ParseSyntaxTree(source);

118syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text) }, references: new MetadataReference[] { }); 122syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text1), SyntaxFactory.ParseSyntaxTree(text2) }, 165syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text1), SyntaxFactory.ParseSyntaxTree(text2) }, 251var comp1 = CSharpCompilation.Create(assemblyName: "Test1", options: TestOptions.DebugExe, syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text1) }, references: new MetadataReference[] { }); 252var comp2 = CSharpCompilation.Create(assemblyName: "Test2", options: TestOptions.DebugExe, syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text2) }, references: new MetadataReference[] { }); 258syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text3) }, 300syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(text1) },

7432var xNodeToSpeculate = SyntaxFactory.ParseExpression("-x"); 7433var yNodeToSpeculate = SyntaxFactory.ParseExpression("-y"); 7496var xNodeToSpeculate = SyntaxFactory.ParseExpression("-x"); 7497var yNodeToSpeculate = SyntaxFactory.ParseExpression("-y");

32return SyntaxFactory.ParseSyntaxTree(text, path: path); 2683SyntaxFactory.ParseSyntaxTree($@" 2689SyntaxFactory.ParseSyntaxTree(@" 2693SyntaxFactory.ParseSyntaxTree(@" 2726SyntaxFactory.ParseSyntaxTree(@" 2731SyntaxFactory.ParseSyntaxTree(@" 2792new[] { SyntaxFactory.ParseSyntaxTree(@"#r ""bar""", TestOptions.Script, "a.csx", Encoding.UTF8) }, 2806SyntaxFactory.ParseSyntaxTree(@" 2810SyntaxFactory.ParseSyntaxTree(@" 2834SyntaxFactory.ParseSyntaxTree(@" 2860var st = SyntaxFactory.ParseSyntaxTree("class C { static void Main() { new lib.Class1(); } }");

383var tree = SyntaxFactory.ParseSyntaxTree(source); 411ExpressionSyntax sourceExpression3 = SyntaxFactory.IdentifierName("jj"); 417ExpressionSyntax sourceExpression4 = SyntaxFactory.IdentifierName("ss"); 421ExpressionSyntax sourceExpression5 = SyntaxFactory.ParseExpression("100L");

2429var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script.WithLanguageVersion(LanguageVersion.CSharp6)); 3826syntaxTree: SyntaxFactory.ParseSyntaxTree(source0, options: parseOptions), 3832syntaxTree: SyntaxFactory.ParseSyntaxTree(source1, options: parseOptions),

356var tree = SyntaxFactory.ParseSyntaxTree(String.Empty);

3497var tree1 = SyntaxFactory.ParseSyntaxTree(string.Format(sourceTemplate, 1), parseOptions, path: "a.cs"); 3498var tree2 = SyntaxFactory.ParseSyntaxTree(string.Format(sourceTemplate, 2), parseOptions, path: "b.cs");

823var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular);

112syntaxTree: SyntaxFactory.ParseSyntaxTree(src, options: TestOptions.Script),

495var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/MyFile.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 538var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/My<>File.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 569var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/MyGeneratedFile.g.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 590var source1 = SyntaxFactory.ParseSyntaxTree(""" 600var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: path, encoding: Encoding.Default); 623var source1 = SyntaxFactory.ParseSyntaxTree(""" 633var source2 = SyntaxFactory.ParseSyntaxTree(""" 670var source1 = SyntaxFactory.ParseSyntaxTree(""" 680var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: path, encoding: Encoding.Default); 702var source1 = SyntaxFactory.ParseSyntaxTree(""" 712var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: "path/to/File.cs", encoding: Encoding.Default); 805var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: $"path/to/My{badChar}File.cs", encoding: Encoding.Default)); 832var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreview, path: "\uD800.cs")); 867var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/My+File.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: validateSymbols); 3219var newBody = body.AddStatements(SyntaxFactory.ParseStatement("C.M();")); 3260var newBody = body.AddStatements(SyntaxFactory.ParseStatement("C.M();")); 3491SyntaxFactory.ParseSyntaxTree(source1, TestOptions.RegularPreview), 3492SyntaxFactory.ParseSyntaxTree(source2, TestOptions.RegularPreview, path: "path/to/FileB.cs") 3735var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreview, path: "path/to/SomeFile.cs")); 3944var tree = SyntaxFactory.ParseSyntaxTree("""

1160var newSource = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement("_ = o;"); 1363var newSource = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ string? s3 = null; _ = s1 == """" ? s1 : s1; }"); 1370var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"s1"); 1371var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"s3 ??= s1", options: TestOptions.Regular8); 1440var newSource = (BlockSyntax)SyntaxFactory.ParseStatement("{ var y = x ?? new object(); y.ToString(); }"); 1515var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"s1"); 1516var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"s1 ??= """""); 1571var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"Prop"); 1572var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"Prop ??= """""); 2136var newDeclaration = SyntaxFactory.ParseStatement("var o5 = s2;"); 3701var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 3736var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 3779var newStatement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement("_ = o1;"); 4065var speculativeAttribute = SyntaxFactory.Attribute(SyntaxFactory.ParseName("A"), SyntaxFactory.ParseAttributeArgumentList("(o2)")); 4070var speculativeInitializer = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("o1")); 4213var newAttributeUsage = SyntaxFactory.Attribute(SyntaxFactory.ParseName("Attr"), SyntaxFactory.ParseAttributeArgumentList("(Constant)")); 4244var type = SyntaxFactory.ParseTypeName("string"); 4368var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4396var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4424var statement = SyntaxFactory.ParseStatement(@" 4454var statement = SyntaxFactory.ParseStatement(@" 4484var statement = SyntaxFactory.ParseStatement(@" 4514var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4546var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4579var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(" M(out C c)")); 4607var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(@" 4640var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"(M(out C c))")); 4671var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"( 4702var expression = SyntaxFactory.ParseExpression(@"M(out C c)"); 4912var newBody = SyntaxFactory.ParseStatement("Prop.ToString();");

2606syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(refSrc) }, 2698syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(refSrc) },

17519private static string UnaryOperatorName(string op, bool isChecked = false) => OperatorFacts.UnaryOperatorNameFromSyntaxKindIfAny(SyntaxFactory.ParseToken(op).Kind(), isChecked: isChecked); 17521op switch { ">>" => WellKnownMemberNames.RightShiftOperatorName, ">>>" => WellKnownMemberNames.UnsignedRightShiftOperatorName, _ => OperatorFacts.BinaryOperatorNameFromSyntaxKindIfAny(SyntaxFactory.ParseToken(op).Kind(), isChecked: isChecked) };

4262var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 4267var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15717var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 15733var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15752var tree3 = SyntaxFactory.ParseCompilationUnit(text3); 20388var submission = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Script), new[] { MscorlibRef_v4_0_30316_17626, SystemCoreRef });

65syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(source2) }, 119syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree("class C { }") }, 168var c1 = CSharpCompilation.Create("Asm1", syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(code) }); 169var c2 = CSharpCompilation.Create("Asm2", syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(code) }); 184syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(code) });

900var tree = SyntaxFactory.ParseSyntaxTree(text); 1672var tree = SyntaxFactory.ParseSyntaxTree(text); 1756var tree = SyntaxFactory.ParseSyntaxTree(text);

2321SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2350SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2368SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs");

41var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 87var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 137var tree = SyntaxFactory.ParseSyntaxTree(source); 186var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 236var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 304var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 356var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 414var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "a.razor.g.cs");

87SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 144SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "goo.cs"); 182SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 198AssertMappedSpanEqual(SyntaxFactory.ParseSyntaxTree(sampleProgram, path: ""), "class X {}", "", 19, 0, 19, 10, hasMappedPath: false); 199AssertMappedSpanEqual(SyntaxFactory.ParseSyntaxTree(sampleProgram, path: " "), "class X {}", " ", 19, 0, 19, 10, hasMappedPath: false); 214SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "filename.cs"); 235SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 251var syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 265var syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 285var syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 309SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 329syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 349syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 372SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 394SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 410SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram); 427SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram); 428SyntaxTree tree2 = SyntaxFactory.ParseSyntaxTree(sampleProgram); 454SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram, path: "c:\\goo.cs"); 488SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(sampleProgram); 554var node = SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(SyntaxFactory.TriviaList(SyntaxFactory.Whitespace(" ")), "x", default(SyntaxTriviaList))); 559var tree = SyntaxFactory.SyntaxTree(nodeWithBadError); 583var node = SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken); 586var nodeWithBadError = SyntaxFactory.IdentifierName(new SyntaxToken(node.Node.WithDiagnosticsGreen(new DiagnosticInfo[] { new SyntaxDiagnosticInfo(10, 10, ErrorCode.ERR_NoBaseClass) }))); 587var tree = SyntaxFactory.SyntaxTree(nodeWithBadError);

9990=> SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("Identifier")); 9993=> SyntaxFactory.QualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 9996=> SyntaxFactory.GenericName(SyntaxFactory.Identifier("Identifier"), GenerateTypeArgumentList()); 9999=> SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10002=> SyntaxFactory.AliasQualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonColonToken), GenerateIdentifierName()); 10005=> SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)); 10008=> SyntaxFactory.ArrayType(GenerateIdentifierName(), new SyntaxList<ArrayRankSpecifierSyntax>()); 10011=> SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10014=> SyntaxFactory.PointerType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.AsteriskToken)); 10017=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(FunctionPointerCallingConventionSyntax), GenerateFunctionPointerParameterList()); 10020=> SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<FunctionPointerParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10023=> SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionListSyntax)); 10026=> SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<FunctionPointerUnmanagedCallingConventionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10029=> SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("Name")); 10032=> SyntaxFactory.NullableType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken)); 10035=> SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<TupleElementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10038=> SyntaxFactory.TupleElement(GenerateIdentifierName(), default(SyntaxToken)); 10041=> SyntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 10044=> SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), default(SyntaxToken), GenerateIdentifierName()); 10047=> SyntaxFactory.ScopedType(SyntaxFactory.Token(SyntaxKind.ScopedKeyword), GenerateIdentifierName()); 10050=> SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10053=> SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10056=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryPlusExpression, SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10059=> SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), GenerateIdentifierName()); 10062=> SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusPlusToken)); 10065=> SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10068=> SyntaxFactory.ConditionalAccessExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName()); 10071=> SyntaxFactory.MemberBindingExpression(SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10074=> SyntaxFactory.ElementBindingExpression(GenerateBracketedArgumentList()); 10077=> SyntaxFactory.RangeExpression(default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.DotDotToken), default(ExpressionSyntax)); 10080=> SyntaxFactory.ImplicitElementAccess(GenerateBracketedArgumentList()); 10083=> SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10086=> SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10089=> SyntaxFactory.ConditionalExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateIdentifierName()); 10092=> SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 10095=> SyntaxFactory.BaseExpression(SyntaxFactory.Token(SyntaxKind.BaseKeyword)); 10098=> SyntaxFactory.LiteralExpression(SyntaxKind.ArgListExpression, SyntaxFactory.Token(SyntaxKind.ArgListKeyword)); 10101=> SyntaxFactory.MakeRefExpression(SyntaxFactory.Token(SyntaxKind.MakeRefKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10104=> SyntaxFactory.RefTypeExpression(SyntaxFactory.Token(SyntaxKind.RefTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10107=> SyntaxFactory.RefValueExpression(SyntaxFactory.Token(SyntaxKind.RefValueKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10110=> SyntaxFactory.CheckedExpression(SyntaxKind.CheckedExpression, SyntaxFactory.Token(SyntaxKind.CheckedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10113=> SyntaxFactory.DefaultExpression(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10116=> SyntaxFactory.TypeOfExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10119=> SyntaxFactory.SizeOfExpression(SyntaxFactory.Token(SyntaxKind.SizeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10122=> SyntaxFactory.InvocationExpression(GenerateIdentifierName(), GenerateArgumentList()); 10125=> SyntaxFactory.ElementAccessExpression(GenerateIdentifierName(), GenerateBracketedArgumentList()); 10128=> SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10131=> SyntaxFactory.BracketedArgumentList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10134=> SyntaxFactory.Argument(default(NameColonSyntax), default(SyntaxToken), GenerateIdentifierName()); 10137=> SyntaxFactory.ExpressionColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10140=> SyntaxFactory.NameColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10143=> SyntaxFactory.DeclarationExpression(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10146=> SyntaxFactory.CastExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateIdentifierName()); 10149=> SyntaxFactory.AnonymousMethodExpression(new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), default(ParameterListSyntax), GenerateBlock(), default(ExpressionSyntax)); 10152=> SyntaxFactory.SimpleLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateParameter(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10155=> SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), GenerateIdentifierName()); 10158=> SyntaxFactory.ParenthesizedLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), GenerateParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10161=> SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10164=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArgumentList(), default(InitializerExpressionSyntax)); 10167=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateIdentifierName(), default(ArgumentListSyntax), default(InitializerExpressionSyntax)); 10170=> SyntaxFactory.WithExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.WithKeyword), GenerateInitializerExpression()); 10173=> SyntaxFactory.AnonymousObjectMemberDeclarator(default(NameEqualsSyntax), GenerateIdentifierName()); 10176=> SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<AnonymousObjectMemberDeclaratorSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10179=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArrayType(), default(InitializerExpressionSyntax)); 10182=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10185=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), GenerateIdentifierName(), default(InitializerExpressionSyntax)); 10188=> SyntaxFactory.ImplicitStackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10191=> SyntaxFactory.QueryExpression(GenerateFromClause(), GenerateQueryBody()); 10194=> SyntaxFactory.QueryBody(new SyntaxList<QueryClauseSyntax>(), GenerateSelectClause(), default(QueryContinuationSyntax)); 10197=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName()); 10200=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10203=> SyntaxFactory.JoinClause(SyntaxFactory.Token(SyntaxKind.JoinKeyword), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.OnKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsKeyword), GenerateIdentifierName(), default(JoinIntoClauseSyntax)); 10206=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier")); 10209=> SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName()); 10212=> SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderByKeyword), new SeparatedSyntaxList<OrderingSyntax>()); 10215=> SyntaxFactory.Ordering(SyntaxKind.AscendingOrdering, GenerateIdentifierName(), default(SyntaxToken)); 10218=> SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), GenerateIdentifierName()); 10221=> SyntaxFactory.GroupClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ByKeyword), GenerateIdentifierName()); 10224=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier"), GenerateQueryBody()); 10227=> SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 10230=> SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), new SyntaxList<InterpolatedStringContentSyntax>(), SyntaxFactory.Token(SyntaxKind.InterpolatedStringEndToken)); 10233=> SyntaxFactory.IsPatternExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateDiscardPattern()); 10236=> SyntaxFactory.ThrowExpression(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), GenerateIdentifierName()); 10239=> SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), GenerateIdentifierName()); 10242=> SyntaxFactory.DiscardPattern(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10245=> SyntaxFactory.DeclarationPattern(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10248=> SyntaxFactory.VarPattern(SyntaxFactory.Token(SyntaxKind.VarKeyword), GenerateSingleVariableDesignation()); 10251=> SyntaxFactory.RecursivePattern(default(TypeSyntax), default(PositionalPatternClauseSyntax), default(PropertyPatternClauseSyntax), default(VariableDesignationSyntax)); 10254=> SyntaxFactory.PositionalPatternClause(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10257=> SyntaxFactory.PropertyPatternClause(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10260=> SyntaxFactory.Subpattern(default(BaseExpressionColonSyntax), GenerateDiscardPattern()); 10263=> SyntaxFactory.ConstantPattern(GenerateIdentifierName()); 10266=> SyntaxFactory.ParenthesizedPattern(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10269=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.EqualsEqualsToken), GenerateIdentifierName()); 10272=> SyntaxFactory.TypePattern(GenerateIdentifierName()); 10275=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.OrKeyword), GenerateDiscardPattern()); 10278=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), GenerateDiscardPattern()); 10281=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<PatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), default(VariableDesignationSyntax)); 10284=> SyntaxFactory.SlicePattern(SyntaxFactory.Token(SyntaxKind.DotDotToken), default(PatternSyntax)); 10287=> SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10290=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), GenerateIdentifierName(), default(InterpolationAlignmentClauseSyntax), default(InterpolationFormatClauseSyntax), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10293=> SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Identifier("CommaToken"), GenerateIdentifierName()); 10296=> SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Identifier("ColonToken"), SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10299=> SyntaxFactory.GlobalStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateBlock()); 10302=> SyntaxFactory.Block(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<StatementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10305=> SyntaxFactory.LocalFunctionStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10308=> SyntaxFactory.LocalDeclarationStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), default(SyntaxToken), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10311=> SyntaxFactory.VariableDeclaration(GenerateIdentifierName(), new SeparatedSyntaxList<VariableDeclaratorSyntax>()); 10314=> SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("Identifier"), default(BracketedArgumentListSyntax), default(EqualsValueClauseSyntax)); 10317=> SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10320=> SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("Identifier")); 10323=> SyntaxFactory.DiscardDesignation(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10326=> SyntaxFactory.ParenthesizedVariableDesignation(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<VariableDesignationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10329=> SyntaxFactory.ExpressionStatement(new SyntaxList<AttributeListSyntax>(), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10332=> SyntaxFactory.EmptyStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10335=> SyntaxFactory.LabeledStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateBlock()); 10338=> SyntaxFactory.GotoStatement(SyntaxKind.GotoStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.GotoKeyword), default(SyntaxToken), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10341=> SyntaxFactory.BreakStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.BreakKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10344=> SyntaxFactory.ContinueStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10347=> SyntaxFactory.ReturnStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10350=> SyntaxFactory.ThrowStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ThrowKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10353=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10356=> SyntaxFactory.WhileStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10359=> SyntaxFactory.DoStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.DoKeyword), GenerateBlock(), SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10362=> SyntaxFactory.ForStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ForKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default(VariableDeclarationSyntax), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.SemicolonToken), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10365=> SyntaxFactory.ForEachStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10368=> SyntaxFactory.ForEachVariableStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.ForEachKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10371=> SyntaxFactory.UsingStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default(VariableDeclarationSyntax), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10374=> SyntaxFactory.FixedStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10377=> SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.CheckedKeyword), GenerateBlock()); 10380=> SyntaxFactory.UnsafeStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), GenerateBlock()); 10383=> SyntaxFactory.LockStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10386=> SyntaxFactory.IfStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock(), default(ElseClauseSyntax)); 10389=> SyntaxFactory.ElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), GenerateBlock()); 10392=> SyntaxFactory.SwitchStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.SwitchKeyword), default(SyntaxToken), GenerateIdentifierName(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<SwitchSectionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10395=> SyntaxFactory.SwitchSection(new SyntaxList<SwitchLabelSyntax>(), new SyntaxList<StatementSyntax>()); 10398=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10401=> SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10404=> SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10407=> SyntaxFactory.SwitchExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SwitchExpressionArmSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10410=> SyntaxFactory.SwitchExpressionArm(GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10413=> SyntaxFactory.TryStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.TryKeyword), GenerateBlock(), new SyntaxList<CatchClauseSyntax>(), default(FinallyClauseSyntax)); 10416=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), default(CatchDeclarationSyntax), default(CatchFilterClauseSyntax), GenerateBlock()); 10419=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10422=> SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10425=> SyntaxFactory.FinallyClause(SyntaxFactory.Token(SyntaxKind.FinallyKeyword), GenerateBlock()); 10428=> SyntaxFactory.CompilationUnit(new SyntaxList<ExternAliasDirectiveSyntax>(), new SyntaxList<UsingDirectiveSyntax>(), new SyntaxList<AttributeListSyntax>(), new SyntaxList<MemberDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 10431=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10434=> SyntaxFactory.UsingDirective(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), default(SyntaxToken), default(SyntaxToken), default(NameEqualsSyntax), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10437=> SyntaxFactory.NamespaceDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<ExternAliasDirectiveSyntax>(), new SyntaxList<UsingDirectiveSyntax>(), new SyntaxList<MemberDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default(SyntaxToken)); 10440=> SyntaxFactory.FileScopedNamespaceDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.NamespaceKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken), new SyntaxList<ExternAliasDirectiveSyntax>(), new SyntaxList<UsingDirectiveSyntax>(), new SyntaxList<MemberDeclarationSyntax>()); 10443=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default(AttributeTargetSpecifierSyntax), new SeparatedSyntaxList<AttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10446=> SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10449=> SyntaxFactory.Attribute(GenerateIdentifierName(), default(AttributeArgumentListSyntax)); 10452=> SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<AttributeArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10455=> SyntaxFactory.AttributeArgument(default(NameEqualsSyntax), default(NameColonSyntax), GenerateIdentifierName()); 10458=> SyntaxFactory.NameEquals(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken)); 10461=> SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10464=> SyntaxFactory.TypeParameter(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Identifier("Identifier")); 10467=> SyntaxFactory.ClassDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.ClassKeyword), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), default(ParameterListSyntax), default(BaseListSyntax), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(SyntaxToken), new SyntaxList<MemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10470=> SyntaxFactory.StructDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.StructKeyword), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), default(ParameterListSyntax), default(BaseListSyntax), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(SyntaxToken), new SyntaxList<MemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10473=> SyntaxFactory.InterfaceDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), default(ParameterListSyntax), default(BaseListSyntax), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(SyntaxToken), new SyntaxList<MemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10476=> SyntaxFactory.RecordDeclaration(SyntaxKind.RecordDeclaration, new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Keyword"), default(SyntaxToken), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), default(ParameterListSyntax), default(BaseListSyntax), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(SyntaxToken), new SyntaxList<MemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10479=> SyntaxFactory.EnumDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EnumKeyword), SyntaxFactory.Identifier("Identifier"), default(BaseListSyntax), default(SyntaxToken), new SeparatedSyntaxList<EnumMemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10482=> SyntaxFactory.DelegateDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), GenerateIdentifierName(), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10485=> SyntaxFactory.EnumMemberDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); 10488=> SyntaxFactory.BaseList(SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<BaseTypeSyntax>()); 10491=> SyntaxFactory.SimpleBaseType(GenerateIdentifierName()); 10494=> SyntaxFactory.PrimaryConstructorBaseType(GenerateIdentifierName(), GenerateArgumentList()); 10497=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<TypeParameterConstraintSyntax>()); 10500=> SyntaxFactory.ConstructorConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10503=> SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint, SyntaxFactory.Token(SyntaxKind.ClassKeyword), default(SyntaxToken)); 10506=> SyntaxFactory.TypeConstraint(GenerateIdentifierName()); 10509=> SyntaxFactory.DefaultConstraint(SyntaxFactory.Token(SyntaxKind.DefaultKeyword)); 10512=> SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10515=> SyntaxFactory.EventFieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10518=> SyntaxFactory.ExplicitInterfaceSpecifier(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken)); 10521=> SyntaxFactory.MethodDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10524=> SyntaxFactory.OperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10527=> SyntaxFactory.ConversionOperatorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), GenerateIdentifierName(), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10530=> SyntaxFactory.ConstructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(ConstructorInitializerSyntax), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10533=> SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(SyntaxKind.BaseKeyword), GenerateArgumentList()); 10536=> SyntaxFactory.DestructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.TildeToken), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10539=> SyntaxFactory.PropertyDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(EqualsValueClauseSyntax), default(SyntaxToken)); 10542=> SyntaxFactory.ArrowExpressionClause(SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10545=> SyntaxFactory.EventDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(SyntaxToken)); 10548=> SyntaxFactory.IndexerDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.ThisKeyword), GenerateBracketedParameterList(), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10551=> SyntaxFactory.AccessorList(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<AccessorDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10554=> SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.GetKeyword), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10557=> SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10560=> SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10563=> SyntaxFactory.Parameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); 10566=> SyntaxFactory.FunctionPointerParameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName()); 10569=> SyntaxFactory.IncompleteMember(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax)); 10572=> SyntaxFactory.SkippedTokensTrivia(new SyntaxTokenList()); 10575=> SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, new SyntaxList<XmlNodeSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken)); 10578=> SyntaxFactory.TypeCref(GenerateIdentifierName()); 10581=> SyntaxFactory.QualifiedCref(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateNameMemberCref()); 10584=> SyntaxFactory.NameMemberCref(GenerateIdentifierName(), default(CrefParameterListSyntax)); 10587=> SyntaxFactory.IndexerMemberCref(SyntaxFactory.Token(SyntaxKind.ThisKeyword), default(CrefBracketedParameterListSyntax)); 10590=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.PlusToken), default(CrefParameterListSyntax)); 10593=> SyntaxFactory.ConversionOperatorMemberCref(SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), GenerateIdentifierName(), default(CrefParameterListSyntax)); 10596=> SyntaxFactory.CrefParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10599=> SyntaxFactory.CrefBracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10602=> SyntaxFactory.CrefParameter(default(SyntaxToken), GenerateIdentifierName()); 10605=> SyntaxFactory.XmlElement(GenerateXmlElementStartTag(), new SyntaxList<XmlNodeSyntax>(), GenerateXmlElementEndTag()); 10608=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10611=> SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10614=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 10617=> SyntaxFactory.XmlName(default(XmlPrefixSyntax), SyntaxFactory.Identifier("LocalName")); 10620=> SyntaxFactory.XmlPrefix(SyntaxFactory.Identifier("Prefix"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10623=> SyntaxFactory.XmlTextAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10626=> SyntaxFactory.XmlCrefAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateTypeCref(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10629=> SyntaxFactory.XmlNameAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10632=> SyntaxFactory.XmlText(new SyntaxTokenList()); 10635=> SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.XmlCDataStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCDataEndToken)); 10638=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), GenerateXmlName(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 10641=> SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.XmlCommentStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCommentEndToken)); 10644=> SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 10647=> SyntaxFactory.ElifDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElifKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 10650=> SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool()); 10653=> SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndIfKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10656=> SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10659=> SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndRegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10662=> SyntaxFactory.ErrorDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10665=> SyntaxFactory.WarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10668=> SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10671=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10674=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10677=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), SyntaxFactory.Literal("1", 1), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10680=> SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10683=> SyntaxFactory.LineSpanDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), GenerateLineDirectivePosition(), SyntaxFactory.Token(SyntaxKind.MinusToken), GenerateLineDirectivePosition(), default(SyntaxToken), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10686=> SyntaxFactory.PragmaWarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.DisableKeyword), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10689=> SyntaxFactory.PragmaChecksumDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.PragmaKeyword), SyntaxFactory.Token(SyntaxKind.ChecksumKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10692=> SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10695=> SyntaxFactory.LoadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LoadKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10698=> SyntaxFactory.ShebangDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExclamationToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10701=> SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.NullableKeyword), SyntaxFactory.Token(SyntaxKind.EnableKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());