30private static readonly SyntaxTree s_implicitUsingsSyntaxTree = SyntaxFactory.ParseSyntaxTree(SourceText.From( 1561var 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));

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

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

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

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

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

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

11081var 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(

242return 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)); 475AddResidualTrivia(SyntaxFactory.TriviaList(indentationTrivia, parentTrivia), requiresNewLine: true); 479AddResidualTrivia(SyntaxFactory.TriviaList(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))

149if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 154SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

25using static SyntaxFactory;

27using static SyntaxFactory;

21using static SyntaxFactory;

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

18return [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);

877return SyntaxFactory.ThrowStatement(throwExpression.ThrowKeyword, throwExpression.Expression, semicolonToken); 883return SyntaxFactory.ReturnStatement(expression.WithLeadingTrivia(SyntaxFactory.ElasticSpace)) 886.WithPrependedLeadingTrivia(SyntaxFactory.ElasticMarker); 890return SyntaxFactory.ReturnStatement(expression) 896return 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);

23? SyntaxFactory.Comment(text)

41=> SyntaxFactory.ElasticMarker; 44=> SyntaxFactory.ElasticCarriageReturnLineFeed; 80=> SyntaxFactory.ParseToken(text); 83=> SyntaxFactory.ParseLeadingTrivia(text); 175=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 467var token = SyntaxFactory.ParseToken(identifier); 473var token = SyntaxFactory.ParseToken(identifier); 1350=> SyntaxFactory.AreEquivalent(token1, token2); 1353=> SyntaxFactory.AreEquivalent(node1, node2);

103var candidateReplacementNode = SyntaxFactory.IdentifierName("var"); 193SyntaxFactory.IdentifierName("var").WithTriviaFrom(declarationTypeNode).WithAdditionalAnnotations(annotation));

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

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

22using static SyntaxFactory;

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

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

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

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

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;

22using 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;

19using static SyntaxFactory;

22using static SyntaxFactory;

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

29using static SyntaxFactory;

25using static SyntaxFactory;

23using static SyntaxFactory;

20using static SyntaxFactory;

32using static SyntaxFactory;

22using static SyntaxFactory;

21using 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)),

21using static SyntaxFactory;

18using static SyntaxFactory;

25using static SyntaxFactory;

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

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

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

33using static SyntaxFactory;

24using static SyntaxFactory;

29using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

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

18using 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;

22using static SyntaxFactory;

21using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

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

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

25using static SyntaxFactory;

34=> SyntaxFactory.CarriageReturnLineFeed; 37=> SyntaxFactory.ElasticCarriageReturnLineFeed; 46=> SyntaxFactory.EndOfLine(text); 49=> SyntaxFactory.Comment("//" + text); 53return SyntaxFactory.LocalDeclarationStatement( 62=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 66return SyntaxFactory.VariableDeclaration( 67type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 68[SyntaxFactory.VariableDeclarator( 70expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression))]); 74=> SyntaxFactory.Identifier(identifier); 77=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 80=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 83=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 97=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 106=> SyntaxFactory.InterpolatedStringExpression(startToken, [.. content.Cast<InterpolatedStringContentSyntax>()], endToken); 109=> SyntaxFactory.InterpolatedStringText(textToken); 112=> SyntaxFactory.Token( 119=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 122=> SyntaxFactory.InterpolationAlignmentClause(CommaToken, (ExpressionSyntax)alignment); 125=> SyntaxFactory.InterpolationFormatClause( 127SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 130=> SyntaxFactory.TypeParameterList([.. typeParameterNames.Select(SyntaxFactory.TypeParameter)]); 175return SyntaxFactory.TokenList(result); 198=> SyntaxFactory.IsPatternExpression( 204=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 207=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 210=> SyntaxFactory.DeclarationPattern( 212SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 215=> SyntaxFactory.RelationalPattern(LessThanToken, (ExpressionSyntax)expression); 218=> SyntaxFactory.RelationalPattern(LessThanEqualsToken, (ExpressionSyntax)expression); 221=> SyntaxFactory.RelationalPattern(GreaterThanToken, (ExpressionSyntax)expression); 224=> SyntaxFactory.RelationalPattern(GreaterThanEqualsToken, (ExpressionSyntax)expression); 227=> SyntaxFactory.UnaryPattern(NotKeyword, (PatternSyntax)Parenthesize(pattern)); 230=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 236=> SyntaxFactory.TypePattern((TypeSyntax)type); 239=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)Parenthesize(pattern));

27using static SyntaxFactory; 276.AddAccessorListAccessors(SyntaxFactory

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

176BaseFieldDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 177BaseMethodDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 178BasePropertyDeclarationSyntax => SyntaxFactory.ParseCompilationUnit(WrapInType(textToParse), options: (CSharpParseOptions)tree.Options), 179StatementSyntax => SyntaxFactory.ParseStatement(textToParse, options: (CSharpParseOptions)tree.Options), 180UsingDirectiveSyntax => 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);

1735var node = SyntaxFactory.ParseExpression(code); 2219var tree = SyntaxFactory.ParseSyntaxTree(code, options: TestOptions.Script); 2222var 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);

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

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

4542var s0 = CSharpCompilation.CreateScriptCompilation("s0.dll", SyntaxFactory.ParseSyntaxTree(source0, options: TestOptions.Script), references); 4543var s1 = CSharpCompilation.CreateScriptCompilation("s1.dll", SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.Script), references, previousScriptCompilation: s0); 4553var 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);

4046syntaxTrees: [SyntaxFactory.ParseSyntaxTree("class A { }")],

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

45var tree1 = SyntaxFactory.ParseSyntaxTree("class A { }", encoding: null, path: "Foo.cs"); 46var tree2 = SyntaxFactory.ParseSyntaxTree("class B { }", encoding: null, path: ""); 47var tree3 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class C { }", encoding: null), path: "Bar.cs"); 48var tree4 = SyntaxFactory.ParseSyntaxTree("class D { }", encoding: Encoding.UTF8, path: "Baz.cs"); 65var tree1 = SyntaxFactory.ParseSyntaxTree("class A { public void F() { } }", encoding: Encoding.Unicode, path: "Foo.cs"); 66var tree2 = SyntaxFactory.ParseSyntaxTree("class B { public void F() { } }", encoding: null, path: ""); 67var tree3 = SyntaxFactory.ParseSyntaxTree("class C { public void F() { } }", encoding: new UTF8Encoding(true, false), path: "Bar.cs"); 68var tree4 = SyntaxFactory.ParseSyntaxTree(SourceText.From("class D { public void F() { } }", new UTF8Encoding(false, false)), path: "Baz.cs"); 132var tree1 = SyntaxFactory.ParseCompilationUnit(@" 136var tree2 = SyntaxFactory.ParseCompilationUnit(@" 12307var 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; }");

10492var modifiedTree = SyntaxFactory.ParseSyntaxTree(source.Replace("return null;", "return field;"), parseOptions); 10526var modifiedTree = SyntaxFactory.ParseSyntaxTree(source.Replace("return null;", "return field;"), parseOptions);

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(@" 21295var statement = (LocalDeclarationStatementSyntax)SyntaxFactory.ParseStatement(@" 32505var node0 = SyntaxFactory.ParseCompilationUnit(source); 32507var decl = SyntaxFactory.DeclarationExpression( 32508type: SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("var")), 32509designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("x1"))); 34333.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34334SyntaxFactory.NodeOrTokenList( 34335SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34336SyntaxFactory.Token(SyntaxKind.CommaToken), 34337SyntaxFactory.ParseExpression($"x{i + 1}") 34547.WithSizes(SyntaxFactory.SeparatedList<ExpressionSyntax>( 34548SyntaxFactory.NodeOrTokenList( 34549SyntaxFactory.ParseExpression($"TakeOutParam(true, out var x{i + 1})"), 34550SyntaxFactory.Token(SyntaxKind.CommaToken), 34551SyntaxFactory.ParseExpression($"x{i + 1}") 35665var 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);

22321speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 22473speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

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

348var newLabeledStatement = labeledStatement.ReplaceNode(newLocalDeclaration, SyntaxFactory.ParseStatement("")); 391return SyntaxFactory.ObjectCreationExpression(implicitCreation.NewKeyword, type, implicitCreation.ArgumentList, implicitCreation.Initializer); 409return 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);

18using 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;

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

170=> SyntaxFactory.ParseTypeName(name); 185methodDefinition = methodDefinition.WithPrependedLeadingTrivia(SyntaxFactory.EndOfLine(newLine)); 190methodDefinition = 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));

34using static SyntaxFactory; 192return [.. 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;

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

16using static SyntaxFactory;

31using static SyntaxFactory;

18using static SyntaxFactory;

26using static SyntaxFactory;

12using static SyntaxFactory;

20using static SyntaxFactory;

25using 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;

66return SyntaxFactory.PropertyDeclaration( 72accessorList: SyntaxFactory.AccessorList([.. (IEnumerable<AccessorDeclarationSyntax>)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);

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

18using static SyntaxFactory;

17using static SyntaxFactory;

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

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

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

149if (SyntaxFactory.AreEquivalent(expression, invocationExpression.Expression, topLevel: false)) 154SyntaxFactory.AreEquivalent(expression, memberAccessExpression.Expression, topLevel: false))

25using static SyntaxFactory;

27using static SyntaxFactory;

21using static SyntaxFactory;

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

22using static SyntaxFactory;

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

22using static SyntaxFactory;

18using static SyntaxFactory;

98SyntaxFactory.ParseTypeName("Task")

24using static SyntaxFactory;

412return SyntaxFactory.LiteralExpression(

25using static SyntaxFactory;

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

41=> SyntaxFactory.ParseLeadingTrivia(docCommentText);

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;

22using 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;

19using static SyntaxFactory;

22using static SyntaxFactory;

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

29using static SyntaxFactory;

25using static SyntaxFactory;

23using static SyntaxFactory;

20using static SyntaxFactory;

32using static SyntaxFactory;

22using static SyntaxFactory;

21using 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)),

21using static SyntaxFactory;

18using static SyntaxFactory;

25using static SyntaxFactory;

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

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

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

33using static SyntaxFactory;

24using static SyntaxFactory;

29using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

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

28using static SyntaxFactory;

10using static SyntaxFactory;

17using static SyntaxFactory;

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

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

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

130=> SyntaxFactory.ParseSyntaxTree( 219? ((BaseMethodDeclarationSyntax)SyntaxFactory.SyntaxTree(declaration).GetRoot()).Body 220: (BlockSyntax)SyntaxFactory.SyntaxTree(declaration.Body!).GetRoot(); 235=> 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);

528new[] { SyntaxFactory.ParseSyntaxTree("public class C {}") }, 1116new[] { 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(@"

12119var stmt = SyntaxFactory.ParseStatement(text);

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

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

3128var 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 + " "); 8084var newStmt = SyntaxFactory.ParseStatement("var lam = (int b = M1(4)) => b;"); 8085var 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();

975var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1047var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1129var tree2 = SyntaxFactory.ParseSyntaxTree(source + " "); 1210var tree2 = SyntaxFactory.ParseSyntaxTree(source + " ");

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

2229var type = SyntaxFactory.ParseTypeName(typeName);

5792var source4 = SyntaxFactory.ParseSyntaxTree(@" 7774SyntaxFactory.SeparatedList<ExpressionSyntax>( 7775new[] { SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)) }), 113787TypeSyntax type = SyntaxFactory.ParseTypeName( 113824TypeSyntax type = SyntaxFactory.ParseTypeName( 113849TypeSyntax type = SyntaxFactory.ParseTypeName( 113874TypeSyntax type = SyntaxFactory.ParseTypeName( 113903TypeSyntax type = SyntaxFactory.ParseTypeName( 113930TypeSyntax type = SyntaxFactory.ParseTypeName( 113958TypeSyntax type = SyntaxFactory.ParseTypeName( 113986TypeSyntax type = SyntaxFactory.ParseTypeName( 114012TypeSyntax type = SyntaxFactory.ParseTypeName( 114050TypeSyntax type = SyntaxFactory.ParseTypeName( 114075TypeSyntax type = SyntaxFactory.ParseTypeName( 114100TypeSyntax type = SyntaxFactory.ParseTypeName( 114129TypeSyntax type = SyntaxFactory.ParseTypeName( 114156TypeSyntax type = SyntaxFactory.ParseTypeName( 114184TypeSyntax type = SyntaxFactory.ParseTypeName( 114212TypeSyntax 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));

10651AssertEx.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(""" 6782var tree = SyntaxFactory.ParseSyntaxTree(""" 10254var tree = SyntaxFactory.ParseSyntaxTree(""" 10290var 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);

3023var tree = SyntaxFactory.ParseSyntaxTree(text, TestOptions.Script); 6597var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6640var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6671var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6735var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6766var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6829var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6862var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6907var 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(); } }");

385var tree = SyntaxFactory.ParseSyntaxTree(source); 413ExpressionSyntax sourceExpression3 = SyntaxFactory.IdentifierName("jj"); 419ExpressionSyntax sourceExpression4 = SyntaxFactory.IdentifierName("ss"); 423ExpressionSyntax 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) };

4323var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 4328var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15809var tree1 = SyntaxFactory.ParseCompilationUnit(text1); 15825var tree2 = SyntaxFactory.ParseCompilationUnit(text2); 15844var tree3 = SyntaxFactory.ParseCompilationUnit(text3); 20480var 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);

2356SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2385SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(text, path: "goo.cs"); 2403SyntaxTree 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);

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

30return SyntaxFactory.ParseSyntaxTree(itext, options); 37return SyntaxFactory.ParseSyntaxTree(itext, options); 182var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 200var interfaceKeyword = SyntaxFactory.ParseToken("struct"); // prime the memoizer 436var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 460var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 490var tree = SyntaxFactory.ParseSyntaxTree(source); 500var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 522var tree = SyntaxFactory.ParseSyntaxTree(source); 532var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 562var tree = SyntaxFactory.ParseSyntaxTree(source); 579var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 613var initialTree = SyntaxFactory.ParseSyntaxTree(initialSource); 843var fullTree = SyntaxFactory.ParseSyntaxTree(withCloseBraceDeletedText.ToString()); 913var startTree = SyntaxFactory.ParseSyntaxTree(text); 962var startTree = SyntaxFactory.ParseSyntaxTree(text); 976var startTree = SyntaxFactory.ParseSyntaxTree(text); 1183SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1204SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1223SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1429SyntaxTree oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1444var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1458SyntaxTree origTree = SyntaxFactory.ParseSyntaxTree(oldText); 1466SyntaxTree fullTree = SyntaxFactory.ParseSyntaxTree(newText); 1576var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1982var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 2745var tree = SyntaxFactory.ParseSyntaxTree(text); 2752var parsedTree = SyntaxFactory.ParseSyntaxTree(text2); 2766var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 2772var parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 2782var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2795var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2811var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2826var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2841var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 2853var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 2896var comp = CSharpTestBase.CreateCompilation(SyntaxFactory.ParseSyntaxTree(String.Empty)); 2906var fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 2920fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 2976var currTree = SyntaxFactory.ParseSyntaxTree(text); 2990var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 3016var currTree = SyntaxFactory.ParseSyntaxTree(text); 3026var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 3044var oldTree = SyntaxFactory.ParseSyntaxTree(text); 3053var tempTree = SyntaxFactory.ParseSyntaxTree(text); 3060var oldTree = SyntaxFactory.SyntaxTree(oldRoot, options: tempTree.Options, path: tempTree.FilePath); 3098var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); // f is a simple lambda parameter 3104var fullTree = SyntaxFactory.ParseSyntaxTree(newText); 3116var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 3181var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 3183WalkTreeAndVerify(newTree.GetCompilationUnitRoot(), SyntaxFactory.ParseSyntaxTree(newText).GetCompilationUnitRoot()); 3196var tree = SyntaxFactory.ParseSyntaxTree(source); 3202var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3217var tree = SyntaxFactory.ParseSyntaxTree(src); 3223var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3238var tree = SyntaxFactory.ParseSyntaxTree(source); 3244var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3259var tree = SyntaxFactory.ParseSyntaxTree(source); 3265var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3280var tree = SyntaxFactory.ParseSyntaxTree(source); 3286var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3301var tree = SyntaxFactory.ParseSyntaxTree(source); 3308var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3325var tree = SyntaxFactory.ParseSyntaxTree(source); 3332var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3349var tree = SyntaxFactory.ParseSyntaxTree(source); 3356var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3373var tree = SyntaxFactory.ParseSyntaxTree(source); 3380var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3397var tree = SyntaxFactory.ParseSyntaxTree(source); 3404var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3421var tree = SyntaxFactory.ParseSyntaxTree(source); 3428var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3447var tree = SyntaxFactory.ParseSyntaxTree(source); 3454var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3473var tree = SyntaxFactory.ParseSyntaxTree(source); 3479var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3498var tree = SyntaxFactory.ParseSyntaxTree(source); 3505var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3524var tree = SyntaxFactory.ParseSyntaxTree(source); 3531var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3542var tree = SyntaxFactory.ParseSyntaxTree(source); 3549var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3560var tree = SyntaxFactory.ParseSyntaxTree(source); 3567var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3578var tree = SyntaxFactory.ParseSyntaxTree(source); 3585var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3593var tree = SyntaxFactory.ParseSyntaxTree(source); 3599var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3607var tree = SyntaxFactory.ParseSyntaxTree(source); 3613var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3621var tree = SyntaxFactory.ParseSyntaxTree(source); 3628var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3659var tree = SyntaxFactory.ParseSyntaxTree(source); 3665var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3680var tree = SyntaxFactory.ParseSyntaxTree(source); 3702var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3731var tree = SyntaxFactory.ParseSyntaxTree(oldText); 3733parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3739var tree = SyntaxFactory.ParseSyntaxTree(oldText); 3741parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3760var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 3766parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3771var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 3774parsedTree = 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();

21return 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();

21return SyntaxFactory.ParseName(text); 26return SyntaxFactory.ParseTypeName(text); 779var tok = SyntaxFactory.ParseToken(text); 795var 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); 365_ = 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);

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