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

44_tree = SyntaxFactory.ParseSyntaxTree(_text);

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

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

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

81var parsedStatement = SyntaxFactory.ParseStatement(statement);

35var parsedStatement = SyntaxFactory.ParseStatement(statement);

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

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

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

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

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

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

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

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

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

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

171var expression = SyntaxFactory.GetStandaloneExpression(type); 202expression = SyntaxFactory.GetStandaloneExpression(expression); 2219var tmp = SyntaxFactory.GetStandaloneNode(node); 2326bindableParent = SyntaxFactory.GetStandaloneExpression(arrayType);

241var loadedTree = SyntaxFactory.ParseSyntaxTree(

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

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

275return SyntaxFactory.TokenList(items);

254var identifierName = SyntaxFactory.IdentifierName(symbol.Name); 293var token = SyntaxFactory.ParseToken(nameWithoutAttributeSuffix);

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

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

2104return SyntaxFactory.GetStandaloneNode(expression) as ExpressionSyntax ?? expression; 2287return SyntaxFactory.BinaryExpression(expression.Kind(), max.Expression, max.OperatorToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2295return SyntaxFactory.QualifiedName(qn.Left, qn.DotToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2303return SyntaxFactory.AliasQualifiedName(an.Alias, an.ColonColonToken, SyntaxFactory.IdentifierName(gn.Identifier)); 2429return SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), value, SyntaxFactory.Token(SyntaxKind.ColonToken)); 2435return SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 2458return SyntaxFactory.PropertyDeclaration( 2479return SyntaxFactory.ConversionOperatorDeclaration( 2501return SyntaxFactory.ConversionOperatorDeclaration( 2523return SyntaxFactory.ConversionOperatorDeclaration( 2547return SyntaxFactory.ConversionOperatorDeclaration( 2572return SyntaxFactory.OperatorDeclaration( 2596return SyntaxFactory.OperatorDeclaration( 2619return SyntaxFactory.OperatorDeclaration( 2643return SyntaxFactory.OperatorDeclaration( 2688=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body, expressionBody: null); 2690=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body, expressionBody: null, semicolonToken); 2692=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, body: null, expressionBody); 2694=> SyntaxFactory.AccessorDeclaration(kind, attributeLists, modifiers, keyword, body: null, expressionBody, semicolonToken); 2724var openParen = needsParens ? SyntaxFactory.Token(SyntaxKind.OpenParenToken) : default; 2725var closeParen = needsParens ? SyntaxFactory.Token(SyntaxKind.CloseParenToken) : default; 2726return SyntaxFactory.SwitchStatement( 2728SyntaxFactory.Token(SyntaxKind.SwitchKeyword), 2732SyntaxFactory.Token(SyntaxKind.OpenBraceToken), 2734SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 2740return SyntaxFactory.SwitchStatement(expression, default(SyntaxList<SwitchSectionSyntax>)); 2771? AnonymousMethodExpression(default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), parameterList, block, null) 2838return SyntaxFactory.OperatorMemberCref( 2848return SyntaxFactory.ConversionOperatorMemberCref( 2859return SyntaxFactory.ClassDeclaration( 2868return SyntaxFactory.ClassDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2873=> SyntaxFactory.ClassDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2877=> SyntaxFactory.ClassDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.ClassKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2881=> 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); 2886return SyntaxFactory.StructDeclaration( 2895return SyntaxFactory.StructDeclaration(attributeLists, modifiers, identifier, typeParameterList, parameterList: null, baseList, constraintClauses, members); 2900=> SyntaxFactory.StructDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, typeParameterList, parameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2904=> SyntaxFactory.StructDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.StructKeyword), identifier, null, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2908=> 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); 2918=> SyntaxFactory.InterfaceDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, typeParameterList, baseList, constraintClauses, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2922=> SyntaxFactory.InterfaceDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.InterfaceKeyword), identifier, null, null, default, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2926=> 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); 2930=> SyntaxFactory.EnumDeclaration(attributeLists, modifiers, SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, baseList, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), members, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2934=> SyntaxFactory.EnumDeclaration(default, default(SyntaxTokenList), SyntaxFactory.Token(SyntaxKind.EnumKeyword), identifier, null, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), default, SyntaxFactory.Token(SyntaxKind.CloseBraceToken), default); 2938=> 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);

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

150if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 155SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

24using static SyntaxFactory;

25using static SyntaxFactory;

20using static SyntaxFactory;

12using static SyntaxFactory;

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

7using static SyntaxFactory;

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

27block = SyntaxFactory.Block(statement);

95var parsed = SyntaxFactory.ParseStatement(nextTrivia.ToFullString()); 131arrowExpression = SyntaxFactory.ArrowExpressionClause(expression); 206expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

882return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 888return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 891.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 895return SyntaxFactory.ReturnStatement(expression) 901return SyntaxFactory.ExpressionStatement(expression)

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

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

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

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

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

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

40=> SyntaxFactory.ElasticMarker; 43=> SyntaxFactory.ElasticCarriageReturnLineFeed; 76=> SyntaxFactory.ParseToken(text); 79=> SyntaxFactory.ParseLeadingTrivia(text); 171=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 460var token = SyntaxFactory.ParseToken(identifier); 466var token = SyntaxFactory.ParseToken(identifier); 1343=> SyntaxFactory.AreEquivalent(token1, token2); 1346=> SyntaxFactory.AreEquivalent(node1, node2);

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

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

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

18using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

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

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

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

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

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

65identifierToken = SyntaxFactory.Token( 91identifierToken = SyntaxFactory.Token(

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

28using static SyntaxFactory;

24using static SyntaxFactory;

74var yieldStatement = SyntaxFactory.YieldStatement(

24using static SyntaxFactory;

21using static SyntaxFactory;

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

366var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

78.WithTrailingTrivia(SyntaxFactory.Space); 97replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

23using static SyntaxFactory;

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

16using static SyntaxFactory;

38var block = SyntaxFactory.Block(statement);

53return SyntaxFactory.BinaryExpression( 66SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

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

22using static SyntaxFactory;

22using static SyntaxFactory;

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

25using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

20using static SyntaxFactory;

32using static SyntaxFactory;

20using static SyntaxFactory;

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

24using static SyntaxFactory;

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

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

23using static SyntaxFactory;

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

18using static SyntaxFactory;

25using static SyntaxFactory;

24using static SyntaxFactory;

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

29using static SyntaxFactory;

16=> SyntaxFactory.PrefixUnaryExpression(

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

23using static SyntaxFactory;

15using static SyntaxFactory;

18using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

30using static SyntaxFactory;

56=> SyntaxFactory.ElementBindingExpression(argumentList);

88return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens);

12using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

23using static SyntaxFactory;

61var updatedCondition = SyntaxFactory.IsPatternExpression( 62isExpression.Left, SyntaxFactory.DeclarationPattern( 64SyntaxFactory.SingleVariableDesignation( 69.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

32using static SyntaxFactory;

24using static SyntaxFactory;

29using static SyntaxFactory;

20using static SyntaxFactory;

23using static SyntaxFactory;

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

17using static SyntaxFactory;

19using static SyntaxFactory;

17using static SyntaxFactory;

23using static SyntaxFactory;

26using static SyntaxFactory;

17using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

21using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

17using static SyntaxFactory;

22using static SyntaxFactory;

20return SyntaxFactory.Block(

14using static SyntaxFactory;

14using static SyntaxFactory;

13using static SyntaxFactory;

21using static SyntaxFactory;

12using static SyntaxFactory;

18using static SyntaxFactory;

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

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

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

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

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

25using static SyntaxFactory;

37=> SyntaxFactory.CarriageReturnLineFeed; 40=> SyntaxFactory.ElasticCarriageReturnLineFeed; 49=> SyntaxFactory.EndOfLine(text); 52=> SyntaxFactory.Comment("//" + text); 56return SyntaxFactory.LocalDeclarationStatement( 65=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 69return SyntaxFactory.VariableDeclaration( 70type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 71[SyntaxFactory.VariableDeclarator( 73expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression))]); 77=> SyntaxFactory.Identifier(identifier); 80=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 83=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 86=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 100=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 109=> SyntaxFactory.InterpolatedStringExpression(startToken, [.. content.Cast<InterpolatedStringContentSyntax>()], endToken); 112=> SyntaxFactory.InterpolatedStringText(textToken); 115=> SyntaxFactory.Token( 122=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 125=> SyntaxFactory.InterpolationAlignmentClause(CommaToken, (ExpressionSyntax)alignment); 128=> SyntaxFactory.InterpolationFormatClause( 130SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 133=> SyntaxFactory.TypeParameterList([.. typeParameterNames.Select(SyntaxFactory.TypeParameter)]); 170=> SyntaxFactory.IsPatternExpression( 176=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 179=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 182=> SyntaxFactory.DeclarationPattern( 184SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 187=> SyntaxFactory.RelationalPattern(LessThanToken, (ExpressionSyntax)expression); 190=> SyntaxFactory.RelationalPattern(LessThanEqualsToken, (ExpressionSyntax)expression); 193=> SyntaxFactory.RelationalPattern(GreaterThanToken, (ExpressionSyntax)expression); 196=> SyntaxFactory.RelationalPattern(GreaterThanEqualsToken, (ExpressionSyntax)expression); 199=> SyntaxFactory.UnaryPattern(NotKeyword, (PatternSyntax)Parenthesize(pattern)); 202=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 208=> SyntaxFactory.TypePattern((TypeSyntax)type); 211=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)Parenthesize(pattern));

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

179BaseFieldDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 180BaseMethodDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 181BasePropertyDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 182StatementSyntax => SyntaxFactory.ParseStatement(textToParse, options: (CSharpParseOptions)tree.Options), 183UsingDirectiveSyntax => SyntaxFactory.ParseCompilationUnit(textToParse, options: (CSharpParseOptions)tree.Options),

21using static SyntaxFactory;

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

39=> SyntaxFactory.ParseSyntaxTree(GetTestFileContent()); 42=> SyntaxFactory.ParseSyntaxTree(code);

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

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

43var root = SyntaxFactory.ParseCompilationUnit(code); 88var root = SyntaxFactory.ParseCompilationUnit(code);

23=> SyntaxFactory.ParseCompilationUnit(expected);

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

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

522=> SyntaxFactory.ParseSyntaxTree(text);

330var originalComp = CreateCompilation([SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs")], assemblyName: "Test"); 331var newComp = CreateCompilation([SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs")], assemblyName: "Test"); 344var src1 = SyntaxFactory.ParseSyntaxTree(""" 353var src2 = SyntaxFactory.ParseSyntaxTree("""

35var parsedStatement = SyntaxFactory.ParseStatement(statement);

33var parsedStatement = SyntaxFactory.ParseStatement(statement);

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

22613var startTree = SyntaxFactory.ParseSyntaxTree(text); 24009var tree = SyntaxFactory.ParseSyntaxTree(text, CSharpParseOptions.Default);

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

2230var syntax = SyntaxFactory.ParseSyntaxTree(@"class C {}", TestOptions.Regular.WithNoRefSafetyRulesAttribute()); 2419var 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),

97if (!SyntaxFactory.AreEquivalent(s0, s1)) 104if (SyntaxFactory.AreEquivalent(p0, p1))

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

44var tree1 = SyntaxFactory.ParseSyntaxTree("class A { }", encoding: null, path: "Foo.cs"); 45var tree2 = SyntaxFactory.ParseSyntaxTree("class B { }", encoding: null, path: ""); 46var tree3 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class C { }", encoding: null), path: "Bar.cs"); 47var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 64var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 65var tree2 = SyntaxFactory.ParseSyntaxTree("class B { public void F() { } }", encoding: null, path: ""); 66var tree3 = SyntaxFactory.ParseSyntaxTree("class C { public void F() { } }", encoding: new UTF8Encoding(true, false), path: "Bar.cs"); 67var tree4 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class D { public void F() { } }", new UTF8Encoding(false, false)), path: "Baz.cs"); 131var tree1 = SyntaxFactory.ParseCompilationUnit(@" 135var tree2 = SyntaxFactory.ParseCompilationUnit(@" 12225var 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")); 751var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 773var result = SyntaxFactory.ParseAttributeArgumentList("[]"); 783var result = SyntaxFactory.ParseAttributeArgumentList("[]", consumeFullText: false); 816var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 857var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 898var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 937var newRoot = root.ReplaceNode(attrSyntax, attrSyntax.WithArgumentList(SyntaxFactory.ParseAttributeArgumentList("()"))); 4889SyntaxFactory.ParseSyntaxTree(

4169SyntaxFactory.ParseSyntaxTree(source1, path: @"C:\filename", encoding: Encoding.UTF8), 4170SyntaxFactory.ParseSyntaxTree(source2, path: @"a\b\..\c\d", encoding: Encoding.UTF8), 4171SyntaxFactory.ParseSyntaxTree(source3, path: @"*", encoding: Encoding.UTF8), 4172SyntaxFactory.ParseSyntaxTree(source4, path: @" ", encoding: Encoding.UTF8), 4211SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Regular9, path: @"C:\filename", encoding: Encoding.UTF8) 4264SyntaxFactory.ParseSyntaxTree(source1, path: @"C:\filename", encoding: Encoding.UTF8), 4265SyntaxFactory.ParseSyntaxTree(source2, path: @"a\b\..\c\d.cs", encoding: Encoding.UTF8), 4266SyntaxFactory.ParseSyntaxTree(source3, path: @"*", encoding: Encoding.UTF8), 4267SyntaxFactory.ParseSyntaxTree(source4, path: @"C:\x.cs", encoding: Encoding.UTF8), 4268SyntaxFactory.ParseSyntaxTree(source5, path: @"C:\x.cs", encoding: Encoding.UTF8), 5171new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5222new[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular7, path: @"C:\filename", encoding: Encoding.UTF8) }, 5292var compilation = CreateCompilationWithMscorlib461(new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular7, path: @"C:\filename") }).VerifyDiagnostics( 5555new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5615new[] { SyntaxFactory.ParseSyntaxTree(source, path: @"C:\filename", encoding: Encoding.UTF8) }, 5670new[] { 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);

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(@" 21292var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@" 32457var node0 = SyntaxFactory.ParseCompilationUnit(source); 32459var decl = SyntaxFactory.DeclarationExpression( 32460type: SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("var")), 32461designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("x1"))); 34285.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34286SyntaxFactory.NodeOrTokenList( 34287SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34288SyntaxFactory.Token(SyntaxKind.CommaToken), 34289SyntaxFactory.ParseExpression($"x{i + 1}") 34499.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34500SyntaxFactory.NodeOrTokenList( 34501SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34502SyntaxFactory.Token(SyntaxKind.CommaToken), 34503SyntaxFactory.ParseExpression($"x{i + 1}") 35617var statementAfter = SyntaxFactory.ParseStatement(@"G(out _);");

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(@"

2164speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 2316speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

22276speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 22428speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

33return SyntaxFactory.Comment(text);

32using static SyntaxFactory;

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

29using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

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

26using static SyntaxFactory;

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

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

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

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

27using static SyntaxFactory;

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

14using static SyntaxFactory;

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

16using static SyntaxFactory;

106var blockSyntax = SyntaxFactory.Block( 107OpenBraceToken.WithLeadingTrivia(SyntaxFactory.ElasticCarriageReturnLineFeed),

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

58=> SyntaxFactory.Token(

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

11using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

20using static SyntaxFactory;

121return SyntaxFactory.ForEachStatement(

19using static SyntaxFactory;

22using static SyntaxFactory;

181=> SyntaxFactory.InvocationExpression( 182SyntaxFactory.MemberAccessExpression( 185SyntaxFactory.IdentifierName(MethodName))).WithAdditionalAnnotations(Formatter.Annotation);

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

19using static SyntaxFactory;

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

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

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

28using static SyntaxFactory;

33using static SyntaxFactory;

15using static SyntaxFactory;

22using static SyntaxFactory;

25using static SyntaxFactory;

31=> SyntaxFactory.ParseExpression(text);

26using static SyntaxFactory;

21using static SyntaxFactory;

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

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

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

55var expression = SyntaxFactory.ParseExpression(expressionValue);

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

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

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

728if (!SyntaxFactory.AreEquivalent(leftBody, rightBody, null)) 756return SyntaxFactory.AreEquivalent(left, right, ignoreChildFunction); 761return SyntaxFactory.AreEquivalent(left.Labels, right.Labels, null) 762&& SyntaxFactory.AreEquivalent(left.Statements, right.Statements, ignoreChildNode: HasLabel); 1517if (weightedDistance == ExactMatchDist && !SyntaxFactory.AreEquivalent(oldNode, newNode)) 1530if (SyntaxFactory.AreEquivalent(oldNode, newNode)) 1553Debug.Assert(!SyntaxFactory.AreEquivalent(leftToken, rightToken) || distance == ExactMatchDist); 1561Debug.Assert(!SyntaxFactory.AreEquivalent(leftNode, rightNode) || distance == ExactMatchDist); 1659=> SyntaxFactory.AreEquivalent(oldElement, newElement); 1667=> SyntaxFactory.AreEquivalent(oldElement, newElement);

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

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

29using static SyntaxFactory;

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

168=> SyntaxFactory.ParseTypeName(name); 182methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SyntaxFactory.EndOfLine(newLine)); 187methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SyntaxFactory.EndOfLine(newLine));

103return SyntaxFactory.EmptyStatement(SyntaxFactory.Token([.. triviaList], SyntaxKind.SemicolonToken, [SyntaxFactory.ElasticMarker])); 117SyntaxFactory.LocalDeclarationStatement( 119SyntaxFactory.VariableDeclaration( 290return SyntaxFactory.Block(statements); 340_statementsOrMemberOrAccessorToInsert.Select(s => global ? SyntaxFactory.GlobalStatement((StatementSyntax)s) : (MemberDeclarationSyntax)s));

33using static SyntaxFactory; 191return [.. AnalyzerResult.MethodTypeParametersInDeclaration.Select(m => SyntaxFactory.ParseTypeName(m.Name))];

40return SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName)); 100expression = SyntaxFactory.ArrayCreationExpression(typeSyntax as ArrayTypeSyntax, containingScope as InitializerExpressionSyntax); 109return [SyntaxFactory.ReturnStatement( 114return [SyntaxFactory.ExpressionStatement( 127return SyntaxFactory.CheckedExpression(kind, expression);

17using static SyntaxFactory;

105return location == TriviaLocation.AfterBeginningOfSpan ? [SyntaxFactory.ElasticMarker] : []; 113return location == TriviaLocation.AfterBeginningOfSpan ? [SyntaxFactory.ElasticMarker] : [];

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

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

21using static SyntaxFactory;

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

13using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

31using static SyntaxFactory;

24using static SyntaxFactory;

170.AddAccessorListAccessors(SyntaxFactory

17using static SyntaxFactory;

26using static SyntaxFactory;

20using static SyntaxFactory;

24using static SyntaxFactory;

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

22using static SyntaxFactory;

26using static SyntaxFactory;

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

33=> SyntaxFactory.ParseExpression(text);

25using static SyntaxFactory;

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

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

27using static SyntaxFactory;

24using static SyntaxFactory;

26using static SyntaxFactory;

61return SyntaxFactory.PropertyDeclaration( 67accessorList: SyntaxFactory.AccessorList([.. accessors.Where(a => a is not null)!]));

26using static SyntaxFactory;

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

35return SyntaxFactory.DoStatement( 36SyntaxFactory.Block(),

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

27using static SyntaxFactory;

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

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

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

31=> SyntaxFactory.PredefinedType(VoidKeyword);

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

18using static SyntaxFactory;

17using static SyntaxFactory;

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

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

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

150if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 155SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

24using static SyntaxFactory;

25using static SyntaxFactory;

20using static SyntaxFactory;

12using static SyntaxFactory;

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

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

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

18using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

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

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

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

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

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

65identifierToken = SyntaxFactory.Token( 91identifierToken = SyntaxFactory.Token(

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

28using static SyntaxFactory;

24using static SyntaxFactory;

74var yieldStatement = SyntaxFactory.YieldStatement(

24using static SyntaxFactory;

21using static SyntaxFactory;

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

366var newFirstMember = firstMember.WithLeadingTrivia(firstMemberTrivia.Insert(0, SyntaxFactory.CarriageReturnLineFeed));

78.WithTrailingTrivia(SyntaxFactory.Space); 97replacementMap[colonToken] = colonToken.WithLeadingTrivia(thisBaseKeyword.LeadingTrivia).WithTrailingTrivia(SyntaxFactory.Space);

23using static SyntaxFactory;

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

16using static SyntaxFactory;

38var block = SyntaxFactory.Block(statement);

53return SyntaxFactory.BinaryExpression( 66SyntaxFactory.TypePattern(((DeclarationPatternSyntax)current).Type)

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

22using static SyntaxFactory;

22using static SyntaxFactory;

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

25using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

20using static SyntaxFactory;

32using static SyntaxFactory;

20using static SyntaxFactory;

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

24using static SyntaxFactory;

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

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

23using static SyntaxFactory;

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

18using static SyntaxFactory;

25using static SyntaxFactory;

24using static SyntaxFactory;

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

29using static SyntaxFactory;

16=> SyntaxFactory.PrefixUnaryExpression(

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

23using static SyntaxFactory;

15using static SyntaxFactory;

18using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

30using static SyntaxFactory;

56=> SyntaxFactory.ElementBindingExpression(argumentList);

88return SyntaxFactory.SeparatedList<ExpressionSyntax>(nodesAndTokens);

12using static SyntaxFactory;

26using static SyntaxFactory;

23using static SyntaxFactory;

23using static SyntaxFactory;

61var updatedCondition = SyntaxFactory.IsPatternExpression( 62isExpression.Left, SyntaxFactory.DeclarationPattern( 64SyntaxFactory.SingleVariableDesignation( 69.SelectMany(t => ImmutableArray.Create(SyntaxFactory.Space, t, SyntaxFactory.ElasticCarriageReturnLineFeed))

32using static SyntaxFactory;

24using static SyntaxFactory;

29using static SyntaxFactory;

20using static SyntaxFactory;

23using static SyntaxFactory;

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

25using static SyntaxFactory;

17using static SyntaxFactory;

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

39var tree = SyntaxFactory.ParseSyntaxTree(source, options); 75var tree = SyntaxFactory.ParseSyntaxTree(source);

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

123=> SyntaxFactory.ParseSyntaxTree( 209? ((BaseMethodDeclarationSyntax)SyntaxFactory.SyntaxTree(declaration).GetRoot()).Body 210: (BlockSyntax)SyntaxFactory.SyntaxTree(declaration.Body!).GetRoot(); 225=> new(oldSource, newSource, source => SyntaxFactory.ParseSyntaxTree(source, path: GetDocumentFilePath(documentIndex)), flags);

23=> SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(n)); 112var distance = SyntaxComparer.ComputeDistance(SyntaxFactory.Literal("abc", "abc"), SyntaxFactory.Literal("acb", "acb"));

21var oldRoot = SyntaxFactory.ParseSyntaxTree(oldSource).GetRoot(); 22var newRoot = SyntaxFactory.ParseSyntaxTree(newSource).GetRoot(); 27Assert.True(SyntaxFactory.AreEquivalent(oldNode, newNode), $"Node '{oldNode}' not equivalent to '{newNode}'."); 73var leftRoot = SyntaxFactory.ParseSyntaxTree(@" 88var rightRoot = SyntaxFactory.ParseSyntaxTree(@" 116var leftRoot = SyntaxFactory.ParseSyntaxTree(@" 135var rightRoot = SyntaxFactory.ParseSyntaxTree(@" 164var tree = SyntaxFactory.ParseSyntaxTree(@" 225var tree = SyntaxFactory.ParseSyntaxTree(@"

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

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

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

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

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

11196var stmt = SyntaxFactory.ParseStatement(text);

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

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

3124var 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)); 1489Assert.True(SyntaxFactory.ParseSyntaxTree(text).GetDiagnostics().Any(d => d.Severity == DiagnosticSeverity.Error));

837var tree = SyntaxFactory.ParseSyntaxTree(source); 946SyntaxFactory.ParseExpression("Goo(() => () => { var x = null; return x; })"), // cast removed 1169var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular9); 1202var tree = SyntaxFactory.ParseSyntaxTree(source); 1234var tree = SyntaxFactory.ParseSyntaxTree(source); 2994var tree = SyntaxFactory.ParseSyntaxTree(source); 3036var tree = SyntaxFactory.ParseSyntaxTree(source); 3985var newTree = SyntaxFactory.ParseSyntaxTree(source + " "); 8090var newStmt = SyntaxFactory.ParseStatement("var lam = (int b = M1(4)) => b;"); 8091var 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(@" 7360=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 7455=> SyntaxFactory.ParseCompilationUnit($@"{source};", options: parseOptions).DescendantNodes().OfType<InvocationExpressionSyntax>().Single(); 7458=> SyntaxFactory.ParseCompilationUnit($@"{source};", options: parseOptions).DescendantNodes().OfType<IdentifierNameSyntax>().Single(); 7532=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 7585=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 8941=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 9445=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single(); 9763=> SyntaxFactory.ParseCompilationUnit($@"class X {{ {source} void M() {{ }} }}", options: parseOptions).DescendantNodes().OfType<AttributeSyntax>().Single();

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

982var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1054var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1136var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1217var tree2 = SyntaxFactory.ParseSyntaxTree(source + " ");

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

2229var type = SyntaxFactory.ParseTypeName(typeName);

5782var source4 = SyntaxFactory.ParseSyntaxTree(@" 7764SyntaxFactory.SeparatedList<ExpressionSyntax>( 7765new[] { SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)) }), 111984TypeSyntax type = SyntaxFactory.ParseTypeName( 112021TypeSyntax type = SyntaxFactory.ParseTypeName( 112046TypeSyntax type = SyntaxFactory.ParseTypeName( 112071TypeSyntax type = SyntaxFactory.ParseTypeName( 112100TypeSyntax type = SyntaxFactory.ParseTypeName( 112127TypeSyntax type = SyntaxFactory.ParseTypeName( 112155TypeSyntax type = SyntaxFactory.ParseTypeName( 112183TypeSyntax type = SyntaxFactory.ParseTypeName( 112209TypeSyntax type = SyntaxFactory.ParseTypeName( 112247TypeSyntax type = SyntaxFactory.ParseTypeName( 112272TypeSyntax type = SyntaxFactory.ParseTypeName( 112297TypeSyntax type = SyntaxFactory.ParseTypeName( 112326TypeSyntax type = SyntaxFactory.ParseTypeName( 112353TypeSyntax type = SyntaxFactory.ParseTypeName( 112381TypeSyntax type = SyntaxFactory.ParseTypeName( 112409TypeSyntax type = SyntaxFactory.ParseTypeName(

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

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

23var tree = SyntaxFactory.ParseSyntaxTree(@" 2612var tree = SyntaxFactory.ParseSyntaxTree(""" 2647var tree = SyntaxFactory.ParseSyntaxTree(""" 2676var tree = SyntaxFactory.ParseSyntaxTree(""" 2871var tree = SyntaxFactory.ParseSyntaxTree(""" 2928var tree = SyntaxFactory.ParseSyntaxTree(""" 2968var tree = SyntaxFactory.ParseSyntaxTree(""" 3178var tree = SyntaxFactory.ParseSyntaxTree(""" 3206var tree = SyntaxFactory.ParseSyntaxTree(""" 3288var tree = SyntaxFactory.ParseSyntaxTree(""" 3375var tree = SyntaxFactory.ParseSyntaxTree(""" 3752var tree = SyntaxFactory.ParseSyntaxTree(""" 3797var tree = SyntaxFactory.ParseSyntaxTree(""" 3900var tree = SyntaxFactory.ParseSyntaxTree(""" 4135var tree = SyntaxFactory.ParseSyntaxTree(""" 6262var tree = SyntaxFactory.ParseSyntaxTree(""" 9678var tree = SyntaxFactory.ParseSyntaxTree(""" 9714var tree = SyntaxFactory.ParseSyntaxTree("""

539var tree = SyntaxFactory.ParseSyntaxTree(@" 1083var 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));

1385new[] { 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");

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

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

47var tree = SyntaxFactory.ParseSyntaxTree(@" 70var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l;}"); 90var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l;}"); 112var tree = SyntaxFactory.ParseSyntaxTree(@" 138var tree = SyntaxFactory.ParseSyntaxTree("class C { long _f = 0l; }"); 165var tree = SyntaxFactory.ParseSyntaxTree(@" class C { long _f = 0l; }"); 166var newTree = SyntaxFactory.ParseSyntaxTree(@" class D { long _f = 0l; }"); 191var tree = SyntaxFactory.ParseSyntaxTree(@" class C { long _f = 0l; }"); 353SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 386new[] { SyntaxFactory.ParseSyntaxTree("class C { static void Main() {} }") }, 614syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree("public class C {}") }, 622syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 633syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 646syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 682syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree("public class C {}", options: TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp6)) }, 690syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 701syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 714syntaxTrees: new SyntaxTree[] { SyntaxFactory.ParseSyntaxTree( 783SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 784SyntaxTree withErrorTree = SyntaxFactory.ParseSyntaxTree(s2); 785SyntaxTree withErrorTree1 = SyntaxFactory.ParseSyntaxTree(s3); 786SyntaxTree withErrorTreeVB = SyntaxFactory.ParseSyntaxTree(s4); 787SyntaxTree withExpressionRootTree = SyntaxFactory.ParseExpression(s3).SyntaxTree; 788var withWarning = SyntaxFactory.ParseSyntaxTree(s5); 791var comp = CSharpCompilation.Create("Compilation", syntaxTrees: new[] { SyntaxFactory.ParseSyntaxTree(s1) }, options: TestOptions.ReleaseDll); 805Assert.False(comp.SyntaxTrees.Contains(SyntaxFactory.ParseSyntaxTree(s1))); 807comp = comp.AddSyntaxTrees(SyntaxFactory.ParseSyntaxTree(s1)); 811comp = comp.ReplaceSyntaxTree(t1, SyntaxFactory.ParseSyntaxTree(s1)); 825Assert.Throws<ArgumentException>(() => comp = comp.RemoveSyntaxTrees(SyntaxFactory.ParseSyntaxTree(s1))); 840SyntaxTree t4 = SyntaxFactory.ParseSyntaxTree("Using System;"); 841SyntaxTree t5 = SyntaxFactory.ParseSyntaxTree("Usingsssssssssssss System;"); 842SyntaxTree t6 = SyntaxFactory.ParseSyntaxTree("Import System;"); 929SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree(s1); 930SyntaxTree t2 = SyntaxFactory.ParseSyntaxTree(s2); 931SyntaxTree t3 = SyntaxFactory.ParseSyntaxTree(s3); 1177var comp1 = CSharpCompilation.Create("Test1", new[] { SyntaxFactory.ParseSyntaxTree(text1) }); 1178var comp2 = CSharpCompilation.Create("Test2", new[] { SyntaxFactory.ParseSyntaxTree(text1) }); 1191new[] { SyntaxFactory.ParseSyntaxTree(text1) }, 1481SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1489Assert.Throws<ArgumentException>(() => comp.ReplaceSyntaxTree(newTree: SyntaxFactory.ParseSyntaxTree("Using System;"), oldTree: t1)); 1541SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1545comp = comp.ReplaceSyntaxTree(newTree: SyntaxFactory.ParseSyntaxTree("Using System;"), oldTree: t1); 1555SyntaxTree t1 = SyntaxFactory.ParseSyntaxTree("Using System;"); 1564SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree("Using Goo;"); 1619SyntaxTree t4 = SyntaxFactory.ParseSyntaxTree(s1); 2379var tree1 = SyntaxFactory.ParseSyntaxTree("", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)); 2380var tree2 = SyntaxFactory.ParseSyntaxTree("", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)); 2381var 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(@" 361var firstTree = SyntaxFactory.ParseSyntaxTree(@" 375var secondTree = SyntaxFactory.ParseSyntaxTree(@" 389var thirdTree = SyntaxFactory.ParseSyntaxTree(@" 428var firstTree = SyntaxFactory.ParseSyntaxTree(@" 442var secondTree = SyntaxFactory.ParseSyntaxTree(@" 474var firstTree = SyntaxFactory.ParseSyntaxTree(@" 488var secondTree = SyntaxFactory.ParseSyntaxTree(@" 517var firstTree = SyntaxFactory.ParseSyntaxTree(@" 536var secondTree = SyntaxFactory.ParseSyntaxTree(@" 577var firstTree = SyntaxFactory.ParseSyntaxTree(@" 596var secondTree = SyntaxFactory.ParseSyntaxTree(@" 631var firstTree = SyntaxFactory.ParseSyntaxTree(@" 645var secondTree = SyntaxFactory.ParseSyntaxTree(@" 674var firstTree = SyntaxFactory.ParseSyntaxTree(@" 688var secondTree = SyntaxFactory.ParseSyntaxTree(@" 717var firstTree = SyntaxFactory.ParseSyntaxTree(@" 733var secondTree = SyntaxFactory.ParseSyntaxTree(@" 764var firstTree = SyntaxFactory.ParseSyntaxTree(@" 780var secondTree = SyntaxFactory.ParseSyntaxTree(@" 809var firstTree = SyntaxFactory.ParseSyntaxTree(@" 823var secondTree = SyntaxFactory.ParseSyntaxTree(@" 854var firstTree = 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); 926var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularWithDocumentationComments); 968var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 969var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1017var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1018var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1068var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1069var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1118var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1119var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1173var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1174var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1221var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1222var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1276var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1277var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1333var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1334var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1396var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1397var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1459var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 1460var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments); 1512var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularWithDocumentationComments); 1555var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1556var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1606var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1607var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1650var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularWithDocumentationComments); 1693var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1694var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1745var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1746var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1796var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1797var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1852var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1853var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1901var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1902var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 1957var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 1958var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 2015var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 2016var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 2079var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 2080var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 2143var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreviewWithDocumentationComments); 2144var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularPreviewWithDocumentationComments); 3227var newLeadingTrivia = SyntaxFactory.ParseToken("/** " + (_count++) + " */1)").LeadingTrivia; 5318var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 5319var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments);

2851var tree = SyntaxFactory.ParseSyntaxTree(text, TestOptions.Script); 6425var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6468var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6499var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6563var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6594var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6657var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6690var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6735var 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); 2684SyntaxFactory.ParseSyntaxTree($@" 2690SyntaxFactory.ParseSyntaxTree(@" 2694SyntaxFactory.ParseSyntaxTree(@" 2727SyntaxFactory.ParseSyntaxTree(@" 2732SyntaxFactory.ParseSyntaxTree(@" 2793new[] { SyntaxFactory.ParseSyntaxTree(@"#r ""bar""", TestOptions.Script, "a.csx", Encoding.UTF8) }, 2807SyntaxFactory.ParseSyntaxTree(@" 2811SyntaxFactory.ParseSyntaxTree(@" 2835SyntaxFactory.ParseSyntaxTree(@" 2861var st = SyntaxFactory.ParseSyntaxTree("class C { static void Main() { new lib.Class1(); } }");

384var tree = SyntaxFactory.ParseSyntaxTree(source); 412ExpressionSyntax sourceExpression3 = SyntaxFactory.IdentifierName("jj"); 418ExpressionSyntax sourceExpression4 = SyntaxFactory.IdentifierName("ss"); 422ExpressionSyntax sourceExpression5 = SyntaxFactory.ParseExpression("100L");

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

357var 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");

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

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

730var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/MyFile.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 773var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/My<>File.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 804var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/MyGeneratedFile.g.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: symbolValidator); 865var source1 = SyntaxFactory.ParseSyntaxTree(""" 875var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: path, encoding: Encoding.Default); 900var source1 = SyntaxFactory.ParseSyntaxTree(""" 910var source2 = SyntaxFactory.ParseSyntaxTree(""" 947var source1 = SyntaxFactory.ParseSyntaxTree(""" 957var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: path, encoding: Encoding.Default); 981var source1 = SyntaxFactory.ParseSyntaxTree(""" 991var source2 = SyntaxFactory.ParseSyntaxTree("", options: TestOptions.RegularPreview, path: "path/to/File.cs", encoding: Encoding.Default); 1086var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: $"path/to/My{badChar}File.cs", encoding: Encoding.Default)); 1113var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreview, path: "\uD800.cs")); 1148var verifier = CompileAndVerify(SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.RegularPreview, path: "path/to/My+File.cs", encoding: Encoding.Default), expectedOutput: "1", symbolValidator: validateSymbols); 3777var newBody = body.AddStatements(SyntaxFactory.ParseStatement("C.M();")); 3818var newBody = body.AddStatements(SyntaxFactory.ParseStatement("C.M();")); 4061SyntaxFactory.ParseSyntaxTree(source1, TestOptions.RegularPreview), 4062SyntaxFactory.ParseSyntaxTree(source2, TestOptions.RegularPreview, path: "path/to/FileB.cs") 4330var comp = CreateCompilation(SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularPreview, path: "path/to/SomeFile.cs")); 4584var tree = SyntaxFactory.ParseSyntaxTree("""

1162var newSource = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement("_ = o;"); 1365var newSource = (BlockSyntax)SyntaxFactory.ParseStatement(@"{ string? s3 = null; _ = s1 == """" ? s1 : s1; }"); 1372var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"s1"); 1373var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"s3 ??= s1", options: TestOptions.Regular8); 1442var newSource = (BlockSyntax)SyntaxFactory.ParseStatement("{ var y = x ?? new object(); y.ToString(); }"); 1517var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"s1"); 1518var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"s1 ??= """""); 1573var newReference = (IdentifierNameSyntax)SyntaxFactory.ParseExpression(@"Prop"); 1574var newCoalesce = (AssignmentExpressionSyntax)SyntaxFactory.ParseExpression(@"Prop ??= """""); 2135var newDeclaration = SyntaxFactory.ParseStatement("var o5 = s2;"); 3700var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 3735var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 3778var newStatement = (ExpressionStatementSyntax)SyntaxFactory.ParseStatement("_ = o1;"); 4064var speculativeAttribute = SyntaxFactory.Attribute(SyntaxFactory.ParseName("A"), SyntaxFactory.ParseAttributeArgumentList("(o2)")); 4069var speculativeInitializer = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("o1")); 4212var newAttributeUsage = SyntaxFactory.Attribute(SyntaxFactory.ParseName("Attr"), SyntaxFactory.ParseAttributeArgumentList("(Constant)")); 4243var type = SyntaxFactory.ParseTypeName("string"); 4367var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4395var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4423var statement = SyntaxFactory.ParseStatement(@" 4453var statement = SyntaxFactory.ParseStatement(@" 4483var statement = SyntaxFactory.ParseStatement(@" 4513var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4545var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4578var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(" M(out C c)")); 4606var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(@" 4639var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"(M(out C c))")); 4670var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"( 4701var expression = SyntaxFactory.ParseExpression(@"M(out C c)"); 4911var newBody = SyntaxFactory.ParseStatement("Prop.ToString();");

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

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

4320var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 4325var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15792var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 15808var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15827var tree3 = SyntaxFactory.ParseCompilationUnit(text3); 20463var 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) });

901var tree = SyntaxFactory.ParseSyntaxTree(text); 1675var tree = SyntaxFactory.ParseSyntaxTree(text); 1759var tree = SyntaxFactory.ParseSyntaxTree(text);

2347SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2376SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2394SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs");

41var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 87var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 134var tree = SyntaxFactory.ParseSyntaxTree(source); 183var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "b.cs"); 233var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 301var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 353var treeB = SyntaxFactory.ParseSyntaxTree(sourceB, path: "page.razor.g.cs"); 411var 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);

10191=> SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("Identifier")); 10194=> SyntaxFactory.QualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10197=> SyntaxFactory.GenericName(SyntaxFactory.Identifier("Identifier"), GenerateTypeArgumentList()); 10200=> SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10203=> SyntaxFactory.AliasQualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonColonToken), GenerateIdentifierName()); 10206=> SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)); 10209=> SyntaxFactory.ArrayType(GenerateIdentifierName(), new SyntaxList<ArrayRankSpecifierSyntax>()); 10212=> SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10215=> SyntaxFactory.PointerType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.AsteriskToken)); 10218=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(FunctionPointerCallingConventionSyntax), GenerateFunctionPointerParameterList()); 10221=> SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<FunctionPointerParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10224=> SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionListSyntax)); 10227=> SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<FunctionPointerUnmanagedCallingConventionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10230=> SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("Name")); 10233=> SyntaxFactory.NullableType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken)); 10236=> SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<TupleElementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10239=> SyntaxFactory.TupleElement(GenerateIdentifierName(), default(SyntaxToken)); 10242=> SyntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 10245=> SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), default(SyntaxToken), GenerateIdentifierName()); 10248=> SyntaxFactory.ScopedType(SyntaxFactory.Token(SyntaxKind.ScopedKeyword), GenerateIdentifierName()); 10251=> SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10254=> SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10257=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryPlusExpression, SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10260=> SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), GenerateIdentifierName()); 10263=> SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusPlusToken)); 10266=> SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10269=> SyntaxFactory.ConditionalAccessExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName()); 10272=> SyntaxFactory.MemberBindingExpression(SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10275=> SyntaxFactory.ElementBindingExpression(GenerateBracketedArgumentList()); 10278=> SyntaxFactory.RangeExpression(default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.DotDotToken), default(ExpressionSyntax)); 10281=> SyntaxFactory.ImplicitElementAccess(GenerateBracketedArgumentList()); 10284=> SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10287=> SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10290=> SyntaxFactory.ConditionalExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateIdentifierName()); 10293=> SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 10296=> SyntaxFactory.BaseExpression(SyntaxFactory.Token(SyntaxKind.BaseKeyword)); 10299=> SyntaxFactory.LiteralExpression(SyntaxKind.ArgListExpression, SyntaxFactory.Token(SyntaxKind.ArgListKeyword)); 10302=> SyntaxFactory.MakeRefExpression(SyntaxFactory.Token(SyntaxKind.MakeRefKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10305=> SyntaxFactory.RefTypeExpression(SyntaxFactory.Token(SyntaxKind.RefTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10308=> SyntaxFactory.RefValueExpression(SyntaxFactory.Token(SyntaxKind.RefValueKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10311=> SyntaxFactory.CheckedExpression(SyntaxKind.CheckedExpression, SyntaxFactory.Token(SyntaxKind.CheckedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10314=> SyntaxFactory.DefaultExpression(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10317=> SyntaxFactory.TypeOfExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10320=> SyntaxFactory.SizeOfExpression(SyntaxFactory.Token(SyntaxKind.SizeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10323=> SyntaxFactory.InvocationExpression(GenerateIdentifierName(), GenerateArgumentList()); 10326=> SyntaxFactory.ElementAccessExpression(GenerateIdentifierName(), GenerateBracketedArgumentList()); 10329=> SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10332=> SyntaxFactory.BracketedArgumentList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10335=> SyntaxFactory.Argument(default(NameColonSyntax), default(SyntaxToken), GenerateIdentifierName()); 10338=> SyntaxFactory.ExpressionColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10341=> SyntaxFactory.NameColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10344=> SyntaxFactory.DeclarationExpression(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10347=> SyntaxFactory.CastExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateIdentifierName()); 10350=> SyntaxFactory.AnonymousMethodExpression(new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), default(ParameterListSyntax), GenerateBlock(), default(ExpressionSyntax)); 10353=> SyntaxFactory.SimpleLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateParameter(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10356=> SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), GenerateIdentifierName()); 10359=> SyntaxFactory.ParenthesizedLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), GenerateParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10362=> SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10365=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArgumentList(), default(InitializerExpressionSyntax)); 10368=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateIdentifierName(), default(ArgumentListSyntax), default(InitializerExpressionSyntax)); 10371=> SyntaxFactory.WithExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.WithKeyword), GenerateInitializerExpression()); 10374=> SyntaxFactory.AnonymousObjectMemberDeclarator(default(NameEqualsSyntax), GenerateIdentifierName()); 10377=> SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<AnonymousObjectMemberDeclaratorSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10380=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArrayType(), default(InitializerExpressionSyntax)); 10383=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10386=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), GenerateIdentifierName(), default(InitializerExpressionSyntax)); 10389=> SyntaxFactory.ImplicitStackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10392=> SyntaxFactory.CollectionExpression(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<CollectionElementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10395=> SyntaxFactory.ExpressionElement(GenerateIdentifierName()); 10398=> SyntaxFactory.SpreadElement(SyntaxFactory.Token(SyntaxKind.DotDotToken), GenerateIdentifierName()); 10401=> SyntaxFactory.QueryExpression(GenerateFromClause(), GenerateQueryBody()); 10404=> SyntaxFactory.QueryBody(new SyntaxList<QueryClauseSyntax>(), GenerateSelectClause(), default(QueryContinuationSyntax)); 10407=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName()); 10410=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10413=> 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)); 10416=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier")); 10419=> SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName()); 10422=> SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderByKeyword), new SeparatedSyntaxList<OrderingSyntax>()); 10425=> SyntaxFactory.Ordering(SyntaxKind.AscendingOrdering, GenerateIdentifierName(), default(SyntaxToken)); 10428=> SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), GenerateIdentifierName()); 10431=> SyntaxFactory.GroupClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ByKeyword), GenerateIdentifierName()); 10434=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier"), GenerateQueryBody()); 10437=> SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 10440=> SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), new SyntaxList<InterpolatedStringContentSyntax>(), SyntaxFactory.Token(SyntaxKind.InterpolatedStringEndToken)); 10443=> SyntaxFactory.IsPatternExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateDiscardPattern()); 10446=> SyntaxFactory.ThrowExpression(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), GenerateIdentifierName()); 10449=> SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), GenerateIdentifierName()); 10452=> SyntaxFactory.DiscardPattern(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10455=> SyntaxFactory.DeclarationPattern(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10458=> SyntaxFactory.VarPattern(SyntaxFactory.Token(SyntaxKind.VarKeyword), GenerateSingleVariableDesignation()); 10461=> SyntaxFactory.RecursivePattern(default(TypeSyntax), default(PositionalPatternClauseSyntax), default(PropertyPatternClauseSyntax), default(VariableDesignationSyntax)); 10464=> SyntaxFactory.PositionalPatternClause(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10467=> SyntaxFactory.PropertyPatternClause(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10470=> SyntaxFactory.Subpattern(default(BaseExpressionColonSyntax), GenerateDiscardPattern()); 10473=> SyntaxFactory.ConstantPattern(GenerateIdentifierName()); 10476=> SyntaxFactory.ParenthesizedPattern(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10479=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.EqualsEqualsToken), GenerateIdentifierName()); 10482=> SyntaxFactory.TypePattern(GenerateIdentifierName()); 10485=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.OrKeyword), GenerateDiscardPattern()); 10488=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), GenerateDiscardPattern()); 10491=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<PatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), default(VariableDesignationSyntax)); 10494=> SyntaxFactory.SlicePattern(SyntaxFactory.Token(SyntaxKind.DotDotToken), default(PatternSyntax)); 10497=> SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10500=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), GenerateIdentifierName(), default(InterpolationAlignmentClauseSyntax), default(InterpolationFormatClauseSyntax), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10503=> SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Identifier("CommaToken"), GenerateIdentifierName()); 10506=> SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Identifier("ColonToken"), SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10509=> SyntaxFactory.GlobalStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateBlock()); 10512=> SyntaxFactory.Block(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<StatementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10515=> SyntaxFactory.LocalFunctionStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10518=> SyntaxFactory.LocalDeclarationStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), default(SyntaxToken), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10521=> SyntaxFactory.VariableDeclaration(GenerateIdentifierName(), new SeparatedSyntaxList<VariableDeclaratorSyntax>()); 10524=> SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("Identifier"), default(BracketedArgumentListSyntax), default(EqualsValueClauseSyntax)); 10527=> SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10530=> SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("Identifier")); 10533=> SyntaxFactory.DiscardDesignation(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10536=> SyntaxFactory.ParenthesizedVariableDesignation(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<VariableDesignationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10539=> SyntaxFactory.ExpressionStatement(new SyntaxList<AttributeListSyntax>(), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10542=> SyntaxFactory.EmptyStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10545=> SyntaxFactory.LabeledStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateBlock()); 10548=> SyntaxFactory.GotoStatement(SyntaxKind.GotoStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.GotoKeyword), default(SyntaxToken), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10551=> SyntaxFactory.BreakStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.BreakKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10554=> SyntaxFactory.ContinueStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10557=> SyntaxFactory.ReturnStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10560=> SyntaxFactory.ThrowStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ThrowKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10563=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10566=> SyntaxFactory.WhileStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10569=> 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)); 10572=> 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()); 10575=> 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()); 10578=> 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()); 10581=> SyntaxFactory.UsingStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default(VariableDeclarationSyntax), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10584=> SyntaxFactory.FixedStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10587=> SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.CheckedKeyword), GenerateBlock()); 10590=> SyntaxFactory.UnsafeStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), GenerateBlock()); 10593=> SyntaxFactory.LockStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10596=> SyntaxFactory.IfStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock(), default(ElseClauseSyntax)); 10599=> SyntaxFactory.ElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), GenerateBlock()); 10602=> 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)); 10605=> SyntaxFactory.SwitchSection(new SyntaxList<SwitchLabelSyntax>(), new SyntaxList<StatementSyntax>()); 10608=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10611=> SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10614=> SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10617=> SyntaxFactory.SwitchExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SwitchExpressionArmSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10620=> SyntaxFactory.SwitchExpressionArm(GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10623=> SyntaxFactory.TryStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.TryKeyword), GenerateBlock(), new SyntaxList<CatchClauseSyntax>(), default(FinallyClauseSyntax)); 10626=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), default(CatchDeclarationSyntax), default(CatchFilterClauseSyntax), GenerateBlock()); 10629=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10632=> SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10635=> SyntaxFactory.FinallyClause(SyntaxFactory.Token(SyntaxKind.FinallyKeyword), GenerateBlock()); 10638=> SyntaxFactory.CompilationUnit(new SyntaxList<ExternAliasDirectiveSyntax>(), new SyntaxList<UsingDirectiveSyntax>(), new SyntaxList<AttributeListSyntax>(), new SyntaxList<MemberDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 10641=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10644=> SyntaxFactory.UsingDirective(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), default(SyntaxToken), default(SyntaxToken), default(NameEqualsSyntax), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10647=> 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)); 10650=> 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>()); 10653=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default(AttributeTargetSpecifierSyntax), new SeparatedSyntaxList<AttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10656=> SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10659=> SyntaxFactory.Attribute(GenerateIdentifierName(), default(AttributeArgumentListSyntax)); 10662=> SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<AttributeArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10665=> SyntaxFactory.AttributeArgument(default(NameEqualsSyntax), default(NameColonSyntax), GenerateIdentifierName()); 10668=> SyntaxFactory.NameEquals(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken)); 10671=> SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10674=> SyntaxFactory.TypeParameter(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Identifier("Identifier")); 10677=> 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)); 10680=> 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)); 10683=> 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)); 10686=> 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)); 10689=> 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)); 10692=> 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)); 10695=> SyntaxFactory.EnumMemberDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); 10698=> SyntaxFactory.BaseList(SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<BaseTypeSyntax>()); 10701=> SyntaxFactory.SimpleBaseType(GenerateIdentifierName()); 10704=> SyntaxFactory.PrimaryConstructorBaseType(GenerateIdentifierName(), GenerateArgumentList()); 10707=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<TypeParameterConstraintSyntax>()); 10710=> SyntaxFactory.ConstructorConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10713=> SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint, SyntaxFactory.Token(SyntaxKind.ClassKeyword), default(SyntaxToken)); 10716=> SyntaxFactory.TypeConstraint(GenerateIdentifierName()); 10719=> SyntaxFactory.DefaultConstraint(SyntaxFactory.Token(SyntaxKind.DefaultKeyword)); 10722=> SyntaxFactory.AllowsConstraintClause(SyntaxFactory.Token(SyntaxKind.AllowsKeyword), new SeparatedSyntaxList<AllowsConstraintSyntax>()); 10725=> SyntaxFactory.RefStructConstraint(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.StructKeyword)); 10728=> SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10731=> SyntaxFactory.EventFieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10734=> SyntaxFactory.ExplicitInterfaceSpecifier(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken)); 10737=> 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)); 10740=> 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)); 10743=> 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)); 10746=> SyntaxFactory.ConstructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(ConstructorInitializerSyntax), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10749=> SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(SyntaxKind.BaseKeyword), GenerateArgumentList()); 10752=> SyntaxFactory.DestructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.TildeToken), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10755=> SyntaxFactory.PropertyDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(EqualsValueClauseSyntax), default(SyntaxToken)); 10758=> SyntaxFactory.ArrowExpressionClause(SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10761=> SyntaxFactory.EventDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(SyntaxToken)); 10764=> SyntaxFactory.IndexerDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.ThisKeyword), GenerateBracketedParameterList(), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10767=> SyntaxFactory.AccessorList(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<AccessorDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10770=> SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.GetKeyword), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10773=> SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10776=> SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10779=> SyntaxFactory.Parameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); 10782=> SyntaxFactory.FunctionPointerParameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName()); 10785=> SyntaxFactory.IncompleteMember(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax)); 10788=> SyntaxFactory.SkippedTokensTrivia(new SyntaxTokenList()); 10791=> SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, new SyntaxList<XmlNodeSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken)); 10794=> SyntaxFactory.TypeCref(GenerateIdentifierName()); 10797=> SyntaxFactory.QualifiedCref(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateNameMemberCref()); 10800=> SyntaxFactory.NameMemberCref(GenerateIdentifierName(), default(CrefParameterListSyntax)); 10803=> SyntaxFactory.IndexerMemberCref(SyntaxFactory.Token(SyntaxKind.ThisKeyword), default(CrefBracketedParameterListSyntax)); 10806=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.PlusToken), default(CrefParameterListSyntax)); 10809=> SyntaxFactory.ConversionOperatorMemberCref(SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), GenerateIdentifierName(), default(CrefParameterListSyntax)); 10812=> SyntaxFactory.CrefParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10815=> SyntaxFactory.CrefBracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10818=> SyntaxFactory.CrefParameter(default(SyntaxToken), default(SyntaxToken), GenerateIdentifierName()); 10821=> SyntaxFactory.XmlElement(GenerateXmlElementStartTag(), new SyntaxList<XmlNodeSyntax>(), GenerateXmlElementEndTag()); 10824=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10827=> SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10830=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 10833=> SyntaxFactory.XmlName(default(XmlPrefixSyntax), SyntaxFactory.Identifier("LocalName")); 10836=> SyntaxFactory.XmlPrefix(SyntaxFactory.Identifier("Prefix"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10839=> SyntaxFactory.XmlTextAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10842=> SyntaxFactory.XmlCrefAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateTypeCref(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10845=> SyntaxFactory.XmlNameAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10848=> SyntaxFactory.XmlText(new SyntaxTokenList()); 10851=> SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.XmlCDataStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCDataEndToken)); 10854=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), GenerateXmlName(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 10857=> SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.XmlCommentStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCommentEndToken)); 10860=> SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 10863=> SyntaxFactory.ElifDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElifKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 10866=> SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool()); 10869=> SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndIfKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10872=> SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10875=> SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndRegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10878=> SyntaxFactory.ErrorDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10881=> SyntaxFactory.WarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10884=> SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10887=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10890=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10893=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), SyntaxFactory.Literal("1", 1), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10896=> SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10899=> 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()); 10902=> 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()); 10905=> 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()); 10908=> SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10911=> SyntaxFactory.LoadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LoadKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10914=> SyntaxFactory.ShebangDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExclamationToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 10917=> SyntaxFactory.NullableDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.NullableKeyword), SyntaxFactory.Token(SyntaxKind.EnableKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool());

29var oldTree = SyntaxFactory.ParseSyntaxTree(text); 197var oldTree = SyntaxFactory.ParseSyntaxTree(topLevel ? topLevelStatement : code, options: options);

67var oldTree = SyntaxFactory.ParseSyntaxTree(text);

264var oldTree = SyntaxFactory.ParseSyntaxTree(code, options: options);

103var oldTree = SyntaxFactory.ParseSyntaxTree(topLevel ? topLevelStatement : code, options: options);

90var originalTree = SyntaxFactory.ParseSyntaxTree(code); 104var parsedRoot = SyntaxFactory.ParseCompilationUnit(syntaxTree.GetText().ToString());

29return SyntaxFactory.ParseSyntaxTree(itext, options); 36return SyntaxFactory.ParseSyntaxTree(itext, options); 181var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 199var interfaceKeyword = SyntaxFactory.ParseToken("struct"); // prime the memoizer 435var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 459var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 489var tree = SyntaxFactory.ParseSyntaxTree(source); 499var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 521var tree = SyntaxFactory.ParseSyntaxTree(source); 531var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 561var tree = SyntaxFactory.ParseSyntaxTree(source); 578var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 651var startTree = SyntaxFactory.ParseSyntaxTree(text); 700var startTree = SyntaxFactory.ParseSyntaxTree(text); 714var startTree = SyntaxFactory.ParseSyntaxTree(text); 921SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 942SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 961SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1167SyntaxTree oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1182var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1196SyntaxTree origTree = SyntaxFactory.ParseSyntaxTree(oldText); 1204SyntaxTree fullTree = SyntaxFactory.ParseSyntaxTree(newText); 1314var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1720var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 2483var tree = SyntaxFactory.ParseSyntaxTree(text); 2490var parsedTree = SyntaxFactory.ParseSyntaxTree(text2); 2504var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 2510var parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 2520var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2533var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2549var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2564var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2579var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2591var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2634var comp = CSharpTestBase.CreateCompilation(SyntaxFactory.ParseSyntaxTree(String.Empty)); 2644var fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 2658fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 2714var currTree = SyntaxFactory.ParseSyntaxTree(text); 2728var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 2754var currTree = SyntaxFactory.ParseSyntaxTree(text); 2764var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 2782var oldTree = SyntaxFactory.ParseSyntaxTree(text); 2791var tempTree = SyntaxFactory.ParseSyntaxTree(text); 2798var oldTree = SyntaxFactory.SyntaxTree(oldRoot, options: tempTree.Options, path: tempTree.FilePath); 2836var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); // f is a simple lambda parameter 2842var fullTree = SyntaxFactory.ParseSyntaxTree(newText); 2854var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 2919var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 2921WalkTreeAndVerify(newTree.GetCompilationUnitRoot(), SyntaxFactory.ParseSyntaxTree(newText).GetCompilationUnitRoot()); 2934var tree = SyntaxFactory.ParseSyntaxTree(source); 2940var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 2955var tree = SyntaxFactory.ParseSyntaxTree(src); 2961var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 2976var tree = SyntaxFactory.ParseSyntaxTree(source); 2982var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 2997var tree = SyntaxFactory.ParseSyntaxTree(source); 3003var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3018var tree = SyntaxFactory.ParseSyntaxTree(source); 3024var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3039var tree = SyntaxFactory.ParseSyntaxTree(source); 3046var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3063var tree = SyntaxFactory.ParseSyntaxTree(source); 3070var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3087var tree = SyntaxFactory.ParseSyntaxTree(source); 3094var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3111var tree = SyntaxFactory.ParseSyntaxTree(source); 3118var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3135var tree = SyntaxFactory.ParseSyntaxTree(source); 3142var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3159var tree = SyntaxFactory.ParseSyntaxTree(source); 3166var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3185var tree = SyntaxFactory.ParseSyntaxTree(source); 3192var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3211var tree = SyntaxFactory.ParseSyntaxTree(source); 3217var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3236var tree = SyntaxFactory.ParseSyntaxTree(source); 3243var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3262var tree = SyntaxFactory.ParseSyntaxTree(source); 3269var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3280var tree = SyntaxFactory.ParseSyntaxTree(source); 3287var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3298var tree = SyntaxFactory.ParseSyntaxTree(source); 3305var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3316var tree = SyntaxFactory.ParseSyntaxTree(source); 3323var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3331var tree = SyntaxFactory.ParseSyntaxTree(source); 3337var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3345var tree = SyntaxFactory.ParseSyntaxTree(source); 3351var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3359var tree = SyntaxFactory.ParseSyntaxTree(source); 3366var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3397var tree = SyntaxFactory.ParseSyntaxTree(source); 3403var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3432var tree = SyntaxFactory.ParseSyntaxTree(oldText); 3434parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3440var tree = SyntaxFactory.ParseSyntaxTree(oldText); 3442parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3461var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 3467parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3472var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 3475parsedTree = SyntaxFactory.ParseSyntaxTree(newText);

155var oldTree = SyntaxFactory.ParseSyntaxTree(text);

79var oldTree = SyntaxFactory.ParseSyntaxTree(topLevel ? topLevelStatement : code, options: options);

43return SyntaxFactory.ParseTokens(text, options: options);

94return SyntaxFactory.ParseSyntaxTree(itext, options).GetCompilationUnitRoot(); 101return SyntaxFactory.ParseSyntaxTree(itext, options); 3213var tree = SyntaxFactory.ParseSyntaxTree(text, path: compilationFileName); 3874var tree = SyntaxFactory.ParseSyntaxTree(text);

187var token = SyntaxFactory.ParseToken(input); 188var literal = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, token);

20var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 37var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 75var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 119var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 158var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 184var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 194var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 203var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 221var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 262var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 273var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 292var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 325var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 355var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 369var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular); 392var parser = SyntaxFactory.CreateTokenParser(sourceText, TestOptions.Regular);

35return SyntaxFactory.ParseSyntaxTree(itext, options); 2948DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 2949SyntaxFactory.XmlSummaryElement( 2950SyntaxFactory.XmlNewLine(Environment.NewLine), 2951SyntaxFactory.XmlText("This class provides extension methods for the "), 2952SyntaxFactory.XmlSeeElement( 2953SyntaxFactory.TypeCref(SyntaxFactory.ParseTypeName("TypeName"))), 2954SyntaxFactory.XmlText(" class."), 2955SyntaxFactory.XmlNewLine(Environment.NewLine)), 2956SyntaxFactory.XmlNewLine(Environment.NewLine), 2957SyntaxFactory.XmlThreadSafetyElement(), 2958SyntaxFactory.XmlNewLine(Environment.NewLine), 2959SyntaxFactory.XmlPreliminaryElement()); 2975DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 2976SyntaxFactory.XmlSummaryElement( 2977SyntaxFactory.XmlNewLine(Environment.NewLine), 2978SyntaxFactory.XmlText("This class provides extension methods."), 2979SyntaxFactory.XmlNewLine(Environment.NewLine))); 2995DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 2996SyntaxFactory.XmlSummaryElement( 2997SyntaxFactory.XmlNewLine(Environment.NewLine), 2998SyntaxFactory.XmlText("This class provides extension methods for the "), 2999SyntaxFactory.XmlSeeElement( 3000SyntaxFactory.TypeCref(SyntaxFactory.ParseTypeName("TypeName"))), 3001SyntaxFactory.XmlText(" class and the "), 3002SyntaxFactory.XmlSeeAlsoElement( 3003SyntaxFactory.TypeCref(SyntaxFactory.ParseTypeName("TypeName2"))), 3004SyntaxFactory.XmlText(" class."), 3005SyntaxFactory.XmlNewLine(Environment.NewLine))); 3016var docComment = SyntaxFactory.DocumentationComment( 3017SyntaxFactory.XmlSeeAlsoElement(new Uri("https://dotnet.microsoft.com/"), 3018SyntaxFactory.List(new XmlNodeSyntax[] { SyntaxFactory.XmlText(".NET") }))); 3039DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3040SyntaxFactory.XmlSummaryElement( 3041SyntaxFactory.XmlNewLine(Environment.NewLine), 3042SyntaxFactory.XmlText("This is a summary."), 3043SyntaxFactory.XmlNewLine(Environment.NewLine)), 3044SyntaxFactory.XmlNewLine(Environment.NewLine), 3045SyntaxFactory.XmlNewLine(Environment.NewLine), 3046SyntaxFactory.XmlNewLine(Environment.NewLine), 3047SyntaxFactory.XmlRemarksElement( 3048SyntaxFactory.XmlNewLine(Environment.NewLine), 3049SyntaxFactory.XmlNewLine(Environment.NewLine))); 3067DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3068SyntaxFactory.XmlSummaryElement( 3069SyntaxFactory.XmlNewLine(Environment.NewLine), 3070SyntaxFactory.XmlParamRefElement("b"), 3071SyntaxFactory.XmlNewLine(Environment.NewLine)), 3072SyntaxFactory.XmlNewLine(Environment.NewLine), 3073SyntaxFactory.XmlParamElement("a"), 3074SyntaxFactory.XmlNewLine(Environment.NewLine), 3075SyntaxFactory.XmlParamElement("b")); 3094DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3095SyntaxFactory.XmlSummaryElement( 3096SyntaxFactory.XmlNewLine(Environment.NewLine), 3097SyntaxFactory.XmlNewLine(Environment.NewLine)), 3098SyntaxFactory.XmlNewLine(Environment.NewLine), 3099SyntaxFactory.XmlReturnsElement( 3100SyntaxFactory.XmlNewLine(Environment.NewLine), 3101SyntaxFactory.XmlText("Returns a value."), 3102SyntaxFactory.XmlNewLine(Environment.NewLine))); 3121DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3122SyntaxFactory.XmlSummaryElement( 3123SyntaxFactory.XmlNewLine(Environment.NewLine), 3124SyntaxFactory.XmlNewLine(Environment.NewLine)), 3125SyntaxFactory.XmlNewLine(Environment.NewLine), 3126SyntaxFactory.XmlRemarksElement( 3127SyntaxFactory.XmlNewLine(Environment.NewLine), 3128SyntaxFactory.XmlText("Same as in class "), 3129SyntaxFactory.XmlSeeElement(SyntaxFactory.TypeCref(SyntaxFactory.ParseTypeName("TypeName"))), 3130SyntaxFactory.XmlText("."), 3131SyntaxFactory.XmlNewLine(Environment.NewLine))); 3148DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3149SyntaxFactory.XmlSummaryElement( 3150SyntaxFactory.XmlNewLine(Environment.NewLine), 3151SyntaxFactory.XmlNewLine(Environment.NewLine)), 3152SyntaxFactory.XmlNewLine(Environment.NewLine), 3153SyntaxFactory.XmlExceptionElement( 3154SyntaxFactory.TypeCref( 3155SyntaxFactory.ParseTypeName("InvalidOperationException")), 3156SyntaxFactory.XmlText("This exception will be thrown if the object is in an invalid state when calling this method."))); 3173DocumentationCommentTriviaSyntax documentationComment = SyntaxFactory.DocumentationComment( 3174SyntaxFactory.XmlSummaryElement( 3175SyntaxFactory.XmlNewLine(Environment.NewLine), 3176SyntaxFactory.XmlNewLine(Environment.NewLine)), 3177SyntaxFactory.XmlNewLine(Environment.NewLine), 3178SyntaxFactory.XmlPermissionElement( 3179SyntaxFactory.TypeCref( 3180SyntaxFactory.ParseTypeName("MyPermission")), 3181SyntaxFactory.XmlText("Needs MyPermission to execute.")));

21return SyntaxFactory.ParseSyntaxTree(text, options: (options ?? TestOptions.Regular).WithLanguageVersion(LanguageVersion.CSharp5)); 26return SyntaxFactory.ParseExpression(text, options: (options ?? TestOptions.Regular).WithLanguageVersion(LanguageVersion.CSharp5));

22return SyntaxFactory.ParseSyntaxTree(text, options: (options ?? TestOptions.Regular).WithLanguageVersion(LanguageVersion.CSharp8)); 27return SyntaxFactory.ParseExpression(text, options: (options ?? TestOptions.Regular).WithLanguageVersion(LanguageVersion.CSharp8));

19return SyntaxFactory.ParseSyntaxTree(text); 24return SyntaxFactory.ParseExpression(text);

29var trivia = SyntaxFactory.ParseLeadingTrivia(commentText, options ?? CSharpParseOptions.Default).Single();

25return SyntaxFactory.ParseSyntaxTree(text, options ?? TestOptions.Regular);

34return SyntaxFactory.ParseSyntaxTree(text, options: options); 1878var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1891var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1903var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1915var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1927var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1944var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1961var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1975var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 1989var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 2005var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 2016var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 2027var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 2036var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature()); 2046var statement = SyntaxFactory.ParseStatement(text, offset: 0, options: TestOptions.Regular.WithTuplesFeature());

22return SyntaxFactory.ParseSyntaxTree(text, options: options); 27return SyntaxFactory.ParseExpression(text, options: options); 2988var expr = SyntaxFactory.ParseExpression(text); 3135var root = SyntaxFactory.ParseSyntaxTree(text).GetRoot();

20return SyntaxFactory.ParseSyntaxTree(text, options ?? TestOptions.Regular);

15Assert.Equal("$\"\"", SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken)).ToFullString()); 21Assert.Equal("$\"goo\"", SyntaxFactory.InterpolatedStringExpression( 22SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), 23SyntaxFactory.SingletonList<InterpolatedStringContentSyntax>( 24SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(

14Assert.Equal("{a}", SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("a")).ToFullString()); 20Assert.Equal("{a,b:c}", SyntaxFactory.Interpolation( 21SyntaxFactory.IdentifierName("a"), 22SyntaxFactory.InterpolationAlignmentClause( 23SyntaxFactory.Token(SyntaxKind.CommaToken), 24SyntaxFactory.IdentifierName("b")), 25SyntaxFactory.InterpolationFormatClause( 26SyntaxFactory.Token(SyntaxKind.ColonToken), 27SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, "c", "c", default))).ToFullString());

24return SyntaxFactory.ParseSyntaxTree(text, options: options); 29return SyntaxFactory.ParseExpression(text, options: options);

22return SyntaxFactory.ParseSyntaxTree(text, options: options); 27return SyntaxFactory.ParseExpression(text, options: options);

18return SyntaxFactory.ParseSyntaxTree(text, options: options); 23return SyntaxFactory.ParseExpression(text, options: options);

20return SyntaxFactory.ParseSyntaxTree(text, options: options); 25return SyntaxFactory.ParseExpression(text, options: options);

25return SyntaxFactory.ParseMemberDeclaration(text, offset, options); 77var d = SyntaxFactory.ParseMemberDeclaration(sb.ToString()); 103var cu = SyntaxFactory.ParseCompilationUnit(sb.ToString()); 144var d = SyntaxFactory.ParseMemberDeclaration("namespace ns {}", options: options);

30var trivia = SyntaxFactory.ParseLeadingTrivia(commentText).Single();

23return SyntaxFactory.ParseName(text); 28return SyntaxFactory.ParseTypeName(text); 781var tok = SyntaxFactory.ParseToken(text); 797var tok = SyntaxFactory.ParseToken(text);

5439var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5442tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp1)); 5461var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5464tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5526var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5529tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5545var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5548tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5588var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5591tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5623var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5626tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5657var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5660tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)); 5694var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)); 5946var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5964var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5977var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 5985tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)); 6006var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 6013tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)); 6036var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 6049tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp4)); 6078var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 6091tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp4)); 6148SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp4)).GetDiagnostics().Verify(); 6149SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)).GetDiagnostics().Verify(); 6160SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6161SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify(); 6184SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6185SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify(); 6215SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp4)).GetDiagnostics().Verify(); 6216SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)).GetDiagnostics().Verify(); 6243SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)).GetDiagnostics().Verify(); 6244SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6271SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp3)).GetDiagnostics().Verify(); 6272SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6285SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6286SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify( 6304SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6305SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify( 6328SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6329SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify( 6348SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6349SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.RegularWithDocumentationComments.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify(); 6365var tree = SyntaxFactory.ParseSyntaxTree(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)); 6380SyntaxFactory.ParseSyntaxTree(source, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp2)).GetDiagnostics().Verify(); 6381SyntaxFactory.ParseSyntaxTree(source, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp1)).GetDiagnostics().Verify(); 6475SyntaxFactory.ParseSyntaxTree(source, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6)).GetDiagnostics().Verify(); 6477SyntaxFactory.ParseSyntaxTree(source, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5)).GetDiagnostics().Verify(); 6579var expr = SyntaxFactory.ParseExpression(builder.ToString()); 6606var stmt = SyntaxFactory.ParseStatement(builder.ToString()); 6627SyntaxFactory.ParseSyntaxTree(source).GetDiagnostics().Verify(

25return SyntaxFactory.ParseSyntaxTree(text, options ?? TestOptions.Regular); 88var tree = SyntaxFactory.ParseSyntaxTree(test); 97var tree = SyntaxFactory.ParseSyntaxTree(test); 107var tree = SyntaxFactory.ParseSyntaxTree(test); 117var tree = SyntaxFactory.ParseSyntaxTree(test); 127var tree = SyntaxFactory.ParseSyntaxTree(test); 137var tree = SyntaxFactory.ParseSyntaxTree(test); 147var tree = SyntaxFactory.ParseSyntaxTree(test); 178SyntaxFactory.ParseExpression(code);

22return SyntaxFactory.ParseCompilationUnit(text, options: options); 7395SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, TestOptions.Regular9); 7414SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7448SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7473SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7498SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7524SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7548SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7573SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7587SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text); 7644var tree = SyntaxFactory.ParseSyntaxTree(source); 7671var tree = SyntaxFactory.ParseSyntaxTree(source); 7760var tree = SyntaxFactory.ParseSyntaxTree(source); 7775var tree = SyntaxFactory.ParseSyntaxTree(source); 7806var tree = SyntaxFactory.ParseSyntaxTree(source); 7840var tree = SyntaxFactory.ParseSyntaxTree(source); 7865var tree = SyntaxFactory.ParseSyntaxTree(source); 7892var tree = SyntaxFactory.ParseSyntaxTree(source); 7906var tree = SyntaxFactory.ParseSyntaxTree(source); 7918var tree = SyntaxFactory.ParseSyntaxTree(source); 7933var root = SyntaxFactory.ParseSyntaxTree(source).GetRoot(); 7954var root = SyntaxFactory.ParseSyntaxTree(source).GetRoot(); 7975var root = SyntaxFactory.ParseSyntaxTree(source).GetRoot(); 7998var root = SyntaxFactory.ParseSyntaxTree(source).GetRoot(); 8022var root = SyntaxFactory.ParseSyntaxTree(source).GetRoot();

78protected virtual SyntaxTree ParseTree(string text, CSharpParseOptions? options) => SyntaxFactory.ParseSyntaxTree(text, options); 81SyntaxFactory.ParseCompilationUnit(text, options: parseOptions); 96var node = SyntaxFactory.ParseStatement(text, options: options); 108var node = SyntaxFactory.ParseMemberDeclaration(text, offset, options, consumeFullText); 123UsingNode(text, SyntaxFactory.ParseExpression(text, options: options), expectedErrors); 361_ = SyntaxFactory.ParseSyntaxTree(stringBuilder.ToString(), TestOptions.RegularPreview);

229UsingNode(SyntaxFactory.ParseExpression("A is B < C, D > [ ]")); 274UsingNode(SyntaxFactory.ParseExpression("A < B > C")); 302SyntaxFactory.ParseExpression("e is A<B> && e").GetDiagnostics().Verify(); 303SyntaxFactory.ParseExpression("e is A<B> || e").GetDiagnostics().Verify(); 304SyntaxFactory.ParseExpression("e is A<B> ^ e").GetDiagnostics().Verify(); 305SyntaxFactory.ParseExpression("e is A<B> | e").GetDiagnostics().Verify(); 306SyntaxFactory.ParseExpression("e is A<B> & e").GetDiagnostics().Verify(); 307SyntaxFactory.ParseExpression("e is A<B>[]").GetDiagnostics().Verify(); 308SyntaxFactory.ParseExpression("new { X = e is A<B> }").GetDiagnostics().Verify(); 309SyntaxFactory.ParseExpression("e is A<B>").GetDiagnostics().Verify(); 311SyntaxFactory.ParseExpression("(item is Dictionary<string, object>[])").GetDiagnostics().Verify(); 312SyntaxFactory.ParseExpression("A is B < C, D > [ ]").GetDiagnostics().Verify(); 313SyntaxFactory.ParseExpression("A is B < C, D > [ ] E").GetDiagnostics().Verify(); 314SyntaxFactory.ParseExpression("A < B > C").GetDiagnostics().Verify(); 320SyntaxFactory.ParseExpression("from s in a where s is string where s.Length > 1 select s").GetDiagnostics().Verify(); 321SyntaxFactory.ParseExpression("M(out int? x)").GetDiagnostics().Verify();

63SyntaxFactory.ParseCompilationUnit(text[0..^i]);

23return SyntaxFactory.ParseSyntaxTree(text, options: options);

1217var tree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Regular8);

23return SyntaxFactory.ParseSyntaxTree(text, options: options);

23return SyntaxFactory.ParseSyntaxTree(text, options: options);

28var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(text), options); 55var tree = SyntaxFactory.ParseSyntaxTree(text); 103var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(text), path: ""); 1582var tree = SyntaxFactory.ParseSyntaxTree(itext, options, ""); 1592var typeOfExpression = SyntaxFactory.ParseExpression(text, consumeFullText: true); 1596typeOfExpression = SyntaxFactory.ParseExpression(text, consumeFullText: false);

25return SyntaxFactory.ParseSyntaxTree(text, options: options ?? TestOptions.Script); 9609var tree = SyntaxFactory.ParseSyntaxTree(test, options: TestOptions.Script);

24return SyntaxFactory.ParseSyntaxTree(text, options: options);

25return SyntaxFactory.ParseSyntaxTree(text, options);

23return SyntaxFactory.ParseStatement(text, offset, options); 3360var tree = SyntaxFactory.ParseStatement(text); 3410var tree = SyntaxFactory.ParseSyntaxTree(text); 3437var tree = SyntaxFactory.ParseSyntaxTree(text, options: new CSharpParseOptions(documentationMode: DocumentationMode.Parse)); 3460var tree = SyntaxFactory.ParseSyntaxTree(source); 3506var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular); 3531var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular);

23return SyntaxFactory.ParseExpression(text, options: options);

19return SyntaxFactory.ParseSyntaxTree(text, options: options);

18return SyntaxFactory.ParseSyntaxTree(text, options: options ?? TestOptions.RegularPreview);

22return SyntaxFactory.ParseSyntaxTree(text, options: options);

29var trivia = SyntaxFactory.ParseLeadingTrivia(commentText).Single();

20var node1 = SyntaxFactory.ReturnStatement(); 21var node2 = SyntaxFactory.ReturnStatement(); 30var node1 = SyntaxFactory.ReturnStatement(); 31var node2 = SyntaxFactory.ReturnStatement();

44var expression = SyntaxFactory.ParseExpression("x"); 45var sw1 = SyntaxFactory.SwitchStatement(expression); 48var sw2 = SyntaxFactory.SwitchStatement(expression, default); 56var expression = SyntaxFactory.ParseExpression("(x)"); 57var sw1 = SyntaxFactory.SwitchStatement(expression); 60var sw2 = SyntaxFactory.SwitchStatement(expression, default); 68var expression = SyntaxFactory.ParseExpression("(1, 2)"); 69var sw1 = SyntaxFactory.SwitchStatement(expression); 72var sw2 = SyntaxFactory.SwitchStatement(expression, default);

42var tree = SyntaxFactory.ParseSyntaxTree(source); 204SyntaxFactory.ParseExpression("F(1)"), 205SyntaxFactory.ParseExpression("F(1)"))); 208SyntaxFactory.ParseExpression("F(1)"), 209SyntaxFactory.ParseExpression("F(2)"))); 212SyntaxFactory.ParseExpression("F(a => 1)"), 213SyntaxFactory.ParseExpression("F(a => 2)"))); 216SyntaxFactory.ParseExpression("F(() => 1)"), 217SyntaxFactory.ParseExpression("F(() => 2)"))); 220SyntaxFactory.ParseExpression("F(delegate { return 1; })"), 221SyntaxFactory.ParseExpression("F(delegate { return 2; })"))); 224SyntaxFactory.ParseExpression("F(delegate (int a) { return 1; })"), 225SyntaxFactory.ParseExpression("F(delegate (bool a) { return 1; })"))); 228SyntaxFactory.ParseExpression("F(delegate (int a) { return 1; })"), 229SyntaxFactory.ParseExpression("F(delegate (int a) { return 2; })"))); 232SyntaxFactory.ParseExpression("F(() => { return 1; })"), 233SyntaxFactory.ParseExpression("F(() => { return 1; })"))); 236SyntaxFactory.ParseExpression("F(() => { return 1; })"), 237SyntaxFactory.ParseExpression("F((a) => { return 1; })"))); 240SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } select a)"), 241SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } select a + 1)"))); 244SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } where a > 0 select a)"), 245SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } where a > 0 select a + 1)"))); 248SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a select a)"), 249SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a select a + 1)"))); 252SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } let b = 1 select a)"), 253SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } let b = 1 select a + 1)"))); 256SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } select a)"), 257SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } where b > 0 select a)"))); 260SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } from b in new[] { 3, 4 } where b > 0 select a)"), 261SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } from b in new[] { 3, 4, 5 } where b > 1 select a + 1)"))); 264SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } join b in new[] { 3, 4 } on a equals b select a)"), 265SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } join b in new[] { 3, 4, 5 } on a equals b select a)"))); 268SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } join b in new[] { 3, 4 } on a equals b select a)"), 269SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } join b in new[] { 3, 4 } on a + 1 equals b + 1 select a)"))); 272SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } select a)"), 273SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } join b in new[] { 3, 4 } on a equals b select a)"))); 276SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a by a into g select g)"), 277SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a + 1 by a into g select g)"))); 280SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a by a into g select g)"), 281SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a by a + 1 into g select g)"))); 284SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a by a into g select g)"), 285SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } group a by a into q select q)"))); 288SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a, a descending, a ascending select a)"), 289SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a + 1, a - 1 descending, a + 1 ascending select a)"))); 292SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a, a descending, a ascending select a)"), 293SyntaxFactory.ParseExpression("F(from a in new[] { 1, 2 } orderby a, a descending, a descending select a)")));

19return SyntaxFactory.MissingToken(token.Kind());

22var node1 = SyntaxFactory.Parameter(SyntaxFactory.Identifier("a")); 23var node2 = SyntaxFactory.Parameter(SyntaxFactory.Identifier("b")); 52: SyntaxFactory.SeparatedList<ExpressionSyntax>(); 53var addList = list.Insert(0, SyntaxFactory.ParseExpression("x")); 56var insertBefore = addList.Insert(0, SyntaxFactory.ParseExpression("y")); 59var insertAfter = addList.Insert(1, SyntaxFactory.ParseExpression("y")); 62var insertBetween = insertAfter.InsertRange(1, new[] { SyntaxFactory.ParseExpression("a"), SyntaxFactory.ParseExpression("b"), SyntaxFactory.ParseExpression("c") }); 66var argsWithComment = SyntaxFactory.ParseArgumentList(@"(a, // a is good 69var insertAfterComment = argsWithComment.Insert(1, SyntaxFactory.Argument(SyntaxFactory.ParseExpression("c"))); 75var argsWithEOL = SyntaxFactory.ParseArgumentList(@"(a, 77var insertAfterEOL = argsWithEOL.Insert(1, SyntaxFactory.Argument(SyntaxFactory.ParseExpression("c"))); 82var argsWithMultiLineComment = SyntaxFactory.ParseArgumentList("(a, /* b is best */ b)").Arguments; 83var insertBeforeMultiLineComment = argsWithMultiLineComment.Insert(1, SyntaxFactory.Argument(SyntaxFactory.ParseExpression("c"))); 92SyntaxFactory.ParseExpression("A"), 93SyntaxFactory.ParseExpression("B"), 94SyntaxFactory.ParseExpression("C")] 95: SyntaxFactory.SeparatedList<SyntaxNode>( 97SyntaxFactory.ParseExpression("A"), 98SyntaxFactory.ParseExpression("B"), 99SyntaxFactory.ParseExpression("C") }); 115SyntaxNode nodeD = SyntaxFactory.ParseExpression("D"); 116SyntaxNode nodeE = SyntaxFactory.ParseExpression("E"); 235DoTestAddInsertRemoveOnEmptyList(SyntaxFactory.SeparatedList<SyntaxNode>()); 244SyntaxNode nodeD = SyntaxFactory.ParseExpression("D"); 245SyntaxNode nodeE = SyntaxFactory.ParseExpression("E"); 281var list = SyntaxFactory.SeparatedList<SyntaxNode>( 283SyntaxFactory.ParseExpression("A+B"), 284SyntaxFactory.IdentifierName("B"), 285SyntaxFactory.ParseExpression("1") }); 304? [SyntaxFactory.IdentifierName("A"), SyntaxFactory.IdentifierName("B"), SyntaxFactory.IdentifierName("C")] 305: SyntaxFactory.SeparatedList<SyntaxNode>( 307SyntaxFactory.IdentifierName("A"), 308SyntaxFactory.IdentifierName("B"), 309SyntaxFactory.IdentifierName("C"), 312var newComma = SyntaxFactory.Token( 313collectionExpression ? SyntaxFactory.TriviaList(SyntaxFactory.Space) : [SyntaxFactory.Space], 315collectionExpression ? SyntaxFactory.TriviaList() : []);