31Assert.Same(fallbackResult, propertyAccessor(SyntaxFactory.AccessorList())); 36Assert.NotNull(withPropertyAccessor(SyntaxFactory.AccessorList(), fallbackResult)); 37Assert.ThrowsAny<NotSupportedException>(() => withPropertyAccessor(SyntaxFactory.AccessorList(), new object())); 69Assert.Same(fallbackResult, accessor(SyntaxFactory.AccessorList(), 0));

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)

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

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

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

39return SyntaxFactory.MethodDeclaration(

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

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

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

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

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

128return SyntaxFactory.TriviaList(sequence);

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); 182_indentations.Add(_useElasticTrivia ? SyntaxFactory.ElasticWhitespace(text) : SyntaxFactory.Whitespace(text)); 1138return SyntaxFactory.TriviaList(currentTriviaList.First()); 1142return SyntaxFactory.TriviaList(currentTriviaList); 1151private static readonly SyntaxTrivia s_trimmedDocCommentExterior = SyntaxFactory.DocumentationCommentExterior("///"); 1155return _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);

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

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

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

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

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

25using static SyntaxFactory;

27using static SyntaxFactory;

21using static SyntaxFactory;

15using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

12using static SyntaxFactory;

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

7using static SyntaxFactory;

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

27block = SyntaxFactory.Block(statement);

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

16SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);

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

107var expr = SyntaxFactory.GetStandaloneExpression(expression);

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

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

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

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

56var parsedNewTrivia = SyntaxFactory.DocumentationCommentExterior(newTriviaText);

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

23? SyntaxFactory.Comment(text)

39=> SyntaxFactory.ElasticMarker; 42=> SyntaxFactory.ElasticCarriageReturnLineFeed; 84=> SyntaxFactory.ParseToken(text); 87=> SyntaxFactory.ParseLeadingTrivia(text); 179=> node is ExpressionSyntax expression ? SyntaxFactory.GetStandaloneExpression(expression) : node; 452var token = SyntaxFactory.ParseToken(identifier); 458var token = SyntaxFactory.ParseToken(identifier); 1275=> SyntaxFactory.AreEquivalent(token1, token2); 1278=> 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(

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

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

29using static SyntaxFactory;

24using static SyntaxFactory;

75var yieldStatement = SyntaxFactory.YieldStatement(

22using static SyntaxFactory;

22using static SyntaxFactory;

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

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

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

23using static SyntaxFactory;

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

16using static SyntaxFactory;

37var block = SyntaxFactory.Block(statement);

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

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

21using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

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

25using static SyntaxFactory;

25using static SyntaxFactory;

22using static SyntaxFactory;

19using static SyntaxFactory;

30using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

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

24using static SyntaxFactory;

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

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

21using static SyntaxFactory;

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;

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

27using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

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

16using static SyntaxFactory;

19using static SyntaxFactory;

17using static SyntaxFactory;

23using static SyntaxFactory;

26using static SyntaxFactory;

17using static SyntaxFactory;

19using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

15using static SyntaxFactory;

22using static SyntaxFactory;

19return SyntaxFactory.Block(

14using static SyntaxFactory;

14using static SyntaxFactory;

14using static SyntaxFactory;

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

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

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

23using static SyntaxFactory;

35=> SyntaxFactory.CarriageReturnLineFeed; 38=> SyntaxFactory.ElasticCarriageReturnLineFeed; 47=> SyntaxFactory.EndOfLine(text); 50=> SyntaxFactory.Comment("//" + text); 54return SyntaxFactory.LocalDeclarationStatement( 63=> SyntaxFactory.EqualsValueClause(operatorToken, (ExpressionSyntax)value); 67return SyntaxFactory.VariableDeclaration( 68type == null ? SyntaxFactory.IdentifierName("var") : (TypeSyntax)type, 69[SyntaxFactory.VariableDeclarator( 71expression == null ? null : SyntaxFactory.EqualsValueClause((ExpressionSyntax)expression))]); 75=> SyntaxFactory.Identifier(identifier); 78=> SyntaxFactory.ConditionalAccessExpression((ExpressionSyntax)expression, (ExpressionSyntax)whenNotNull); 81=> SyntaxFactory.MemberBindingExpression((SimpleNameSyntax)name); 84=> SyntaxFactory.RefExpression((ExpressionSyntax)expression); 98=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, (ExpressionSyntax)expression); 107=> SyntaxFactory.InterpolatedStringExpression(startToken, [.. content.Cast<InterpolatedStringContentSyntax>()], endToken); 110=> SyntaxFactory.InterpolatedStringText(textToken); 113=> SyntaxFactory.Token( 120=> SyntaxFactory.Interpolation((ExpressionSyntax)syntaxNode); 123=> SyntaxFactory.InterpolationAlignmentClause(CommaToken, (ExpressionSyntax)alignment); 126=> SyntaxFactory.InterpolationFormatClause( 128SyntaxFactory.Token(default, SyntaxKind.InterpolatedStringTextToken, format, format, default)); 131=> SyntaxFactory.TypeParameterList([.. typeParameterNames.Select(SyntaxFactory.TypeParameter)]); 176return SyntaxFactory.TokenList(result); 199=> SyntaxFactory.IsPatternExpression( 205=> SyntaxFactory.BinaryPattern(SyntaxKind.AndPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 208=> SyntaxFactory.ConstantPattern((ExpressionSyntax)expression); 211=> SyntaxFactory.DeclarationPattern( 213SyntaxFactory.SingleVariableDesignation(name.ToIdentifierToken())); 216=> SyntaxFactory.RelationalPattern(LessThanToken, (ExpressionSyntax)expression); 219=> SyntaxFactory.RelationalPattern(LessThanEqualsToken, (ExpressionSyntax)expression); 222=> SyntaxFactory.RelationalPattern(GreaterThanToken, (ExpressionSyntax)expression); 225=> SyntaxFactory.RelationalPattern(GreaterThanEqualsToken, (ExpressionSyntax)expression); 228=> SyntaxFactory.UnaryPattern(NotKeyword, (PatternSyntax)Parenthesize(pattern)); 231=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, (PatternSyntax)Parenthesize(left), (PatternSyntax)Parenthesize(right)); 237=> SyntaxFactory.TypePattern((TypeSyntax)type); 240=> SyntaxFactory.UnaryPattern(operatorToken, (PatternSyntax)Parenthesize(pattern)); 245=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)Parenthesize(expression)).WithAdditionalAnnotations(Simplifier.Annotation); 248=> SyntaxFactory.DefaultExpression((TypeSyntax)type).WithAdditionalAnnotations(Simplifier.Annotation); 259return SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression); 265return SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression); 277return SyntaxFactory.LiteralExpression( 278SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal("0", 0)); 290RefKind.Ref => SyntaxFactory.RefType(type), 291RefKind.RefReadOnly => SyntaxFactory.RefType(RefKeyword, ReadOnlyKeyword, type), 301return SyntaxFactory.MemberAccessExpression( 332=> SyntaxFactory.BinaryExpression(syntaxKind, (ExpressionSyntax)Parenthesize(left), (ExpressionSyntax)Parenthesize(right)); 338=> SyntaxFactory.CastExpression((TypeSyntax)type, (ExpressionSyntax)Parenthesize(expression)).WithAdditionalAnnotations(Simplifier.Annotation);

26using static SyntaxFactory; 275.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));

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

522=> SyntaxFactory.ParseSyntaxTree(text);

388var originalComp = CreateCompilation([SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs")], assemblyName: "Test"); 389var newComp = CreateCompilation([SyntaxFactory.ParseSyntaxTree(src1, path: "file1.cs"), SyntaxFactory.ParseSyntaxTree(src1, path: "file2.cs")], assemblyName: "Test"); 402var src1 = SyntaxFactory.ParseSyntaxTree(""" 411var src2 = SyntaxFactory.ParseSyntaxTree("""

35var parsedStatement = SyntaxFactory.ParseStatement(statement);

36var parsedStatement = SyntaxFactory.ParseStatement(statement);

66var 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),

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

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("()"))); 4891SyntaxFactory.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; }");

10478var modifiedTree = SyntaxFactory.ParseSyntaxTree(source.Replace("return null;", "return field;"), parseOptions); 10512var 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(@"

2165speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 2317speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

22381speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList); 22533speculativeBaseInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, speculativePrimaryInitializer.ArgumentList);

31using static SyntaxFactory;

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

29using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

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

26using static SyntaxFactory;

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

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

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;

28using static SyntaxFactory;

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(

18using static SyntaxFactory;

22using static SyntaxFactory;

180=> SyntaxFactory.InvocationExpression( 181SyntaxFactory.MemberAccessExpression( 184SyntaxFactory.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;

28using static SyntaxFactory;

27=> SyntaxFactory.ParseExpression(text);

26using static SyntaxFactory;

20using static SyntaxFactory;

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

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

137var comment = SyntaxFactory.TriviaList( 138SyntaxFactory.Comment($"/* {errorMessage} */"), 139SyntaxFactory.CarriageReturnLineFeed);

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

55var expression = SyntaxFactory.ParseExpression(expressionValue);

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

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

371if (SyntaxFactory.AreEquivalent(left, right)) 584=> SyntaxFactory.CompilationUnit(); 921=> SyntaxFactory.AreEquivalent(oldToken, newToken); 1481=> SyntaxFactory.AreEquivalent; 2666return SyntaxFactory.AreEquivalent(oldTryStatement.Finally, newTryStatement.Finally) 2667&& SyntaxFactory.AreEquivalent(oldTryStatement.Catches, newTryStatement.Catches); 2671return SyntaxFactory.AreEquivalent(oldNode, newNode); 2742if (!SyntaxFactory.AreEquivalent(oldContainingStatementPart, newContainingStatementPart) && 2925return SyntaxFactory.AreEquivalent(oldCasePatternLabel.Pattern, newCasePatternLabel.Pattern) && 2930return SyntaxFactory.AreEquivalent(oldLabel, newLabel); 3088if (!SyntaxFactory.AreEquivalent(oldVariables[i], newVariables[i]))

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

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

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

29using static SyntaxFactory;

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

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

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

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

41return SyntaxFactory.Identifier(nameGenerator.CreateUniqueMethodName(containingScope, methodName)); 97? SyntaxFactory.ArrayCreationExpression((ArrayTypeSyntax)returnType.GenerateTypeSyntax(), initializerExpression) 101? [SyntaxFactory.ReturnStatement(WrapInCheckedExpressionIfNeeded(expression))] 102: [SyntaxFactory.ExpressionStatement(WrapInCheckedExpressionIfNeeded(expression))]; 113return SyntaxFactory.CheckedExpression(kind, expression);

17using static SyntaxFactory;

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

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

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

21using static SyntaxFactory;

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

16using static SyntaxFactory;

31using static SyntaxFactory;

17using static SyntaxFactory;

25using static SyntaxFactory;

12using static SyntaxFactory;

20using static SyntaxFactory;

25using static SyntaxFactory;

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

22using static SyntaxFactory;

26using static SyntaxFactory;

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

33=> SyntaxFactory.ParseExpression(text);

25using static SyntaxFactory;

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

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

26using static SyntaxFactory;

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

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

25using static SyntaxFactory;

27using static SyntaxFactory;

21using static SyntaxFactory;

15using static SyntaxFactory;

20using static SyntaxFactory;

19using static SyntaxFactory;

12using static SyntaxFactory;

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

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(

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

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

29using static SyntaxFactory;

24using static SyntaxFactory;

75var yieldStatement = SyntaxFactory.YieldStatement(

22using static SyntaxFactory;

22using static SyntaxFactory;

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

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

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

23using static SyntaxFactory;

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

16using static SyntaxFactory;

37var block = SyntaxFactory.Block(statement);

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

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

21using static SyntaxFactory;

19using static SyntaxFactory;

22using static SyntaxFactory;

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

25using static SyntaxFactory;

25using static SyntaxFactory;

22using static SyntaxFactory;

19using static SyntaxFactory;

30using static SyntaxFactory;

22using static SyntaxFactory;

20using static SyntaxFactory;

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

24using static SyntaxFactory;

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

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

21using static SyntaxFactory;

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;

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

27using static SyntaxFactory;

20using static SyntaxFactory;

21using static SyntaxFactory;

23using static SyntaxFactory;

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

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

61ReplacementNode = SyntaxFactory.ParseMemberDeclaration(replacementCodeBlock),

445ReplacementNode = SyntaxFactory.ParseCompilationUnit(replacement), 477ReplacementNode = SyntaxFactory.ParseMemberDeclaration(syntax), 491ReplacementNode = SyntaxFactory.ParseMemberDeclaration(emptyReplacement), 566ReplacementNode = SyntaxFactory.ParseMemberDeclaration(implementation),

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

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

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

22=> SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(n)); 111var 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(@"

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

836var tree = SyntaxFactory.ParseSyntaxTree(source); 945SyntaxFactory.ParseExpression("Goo(() => () => { var x = null; return x; })"), // cast removed 1168var tree = SyntaxFactory.ParseSyntaxTree(source, options: TestOptions.Regular9); 1201var tree = SyntaxFactory.ParseSyntaxTree(source); 1233var tree = SyntaxFactory.ParseSyntaxTree(source); 2993var tree = SyntaxFactory.ParseSyntaxTree(source); 3035var tree = SyntaxFactory.ParseSyntaxTree(source); 3984var newTree = SyntaxFactory.ParseSyntaxTree(source + " "); 8076var newStmt = SyntaxFactory.ParseStatement("var lam = (int b = M1(4)) => b;"); 8077var 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));

10723AssertEx.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"); 3125var returnStatement = (ReturnStatementSyntax)SyntaxFactory.ParseStatement(returnStatementCode); 3189var yieldStatement = (YieldStatementSyntax)SyntaxFactory.ParseStatement("yield return 1;"); 3224var yieldStatement = (YieldStatementSyntax)SyntaxFactory.ParseStatement("yield return 1;"); 3254var typeSyntax = SyntaxFactory.ParseTypeName("System.Collections.Generic.IEnumerable<C[]>"); 3295var statementSyntax = SyntaxFactory.ParseStatement("TakesOut(out int x);"); 3336var statementSyntax = SyntaxFactory.ParseStatement("TakesOut(out int x);"); 3377var statementSyntax = SyntaxFactory.ParseExpression("TakesOut(out int x)"); 3411var statementSyntax = SyntaxFactory.ParseStatement("{ TakesOut(out int x); }"); 3453var statementSyntax = SyntaxFactory.ParseStatement("Method(o is string s);"); 3494var statementSyntax = SyntaxFactory.ParseStatement("Method(o is string s);"); 3535var statementSyntax = SyntaxFactory.ParseExpression("Method(o is string s)"); 3588return SyntaxFactory.ParseCompilationUnit(source + " class X {}").Members.First().AsTypeDeclarationSyntax().AttributeLists.First().Attributes.First(); 3616var attributeSyntax = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("Category")); 3651var speculatedName = (GenericNameSyntax)SyntaxFactory.GenericName("List{T}"); 3819var @return = (ReturnStatementSyntax)SyntaxFactory.ParseStatement("return s;"); 4359var typeSyntax = SyntaxFactory.ParseTypeName("dynamic"); 4459var 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); 4282var newLeadingTrivia = SyntaxFactory.ParseToken("/** " + (_count++) + " */1)").LeadingTrivia; 6373var tree1 = SyntaxFactory.ParseSyntaxTree(source1, options: TestOptions.RegularWithDocumentationComments); 6374var tree2 = SyntaxFactory.ParseSyntaxTree(source2, options: TestOptions.RegularWithDocumentationComments);

3138var tree = SyntaxFactory.ParseSyntaxTree(text, TestOptions.Script); 6712var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6755var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6786var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6850var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6881var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6944var srcTree = SyntaxFactory.ParseSyntaxTree(@" 6977var srcTree = SyntaxFactory.ParseSyntaxTree(@" 7022var 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;"); 4061var speculativeAttribute = SyntaxFactory.Attribute(SyntaxFactory.ParseName("A"), SyntaxFactory.ParseAttributeArgumentList("(o2)")); 4066var speculativeInitializer = SyntaxFactory.EqualsValueClause(SyntaxFactory.ParseExpression("o1")); 4209var newAttributeUsage = SyntaxFactory.Attribute(SyntaxFactory.ParseName("Attr"), SyntaxFactory.ParseAttributeArgumentList("(Constant)")); 4240var type = SyntaxFactory.ParseTypeName("string"); 4364var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4392var statement = SyntaxFactory.ParseStatement(@"M(out C c);"); 4420var statement = SyntaxFactory.ParseStatement(@" 4450var statement = SyntaxFactory.ParseStatement(@" 4480var statement = SyntaxFactory.ParseStatement(@" 4510var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4542var methodDeclaration = (MethodDeclarationSyntax)SyntaxFactory.ParseMemberDeclaration(@" 4575var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(" M(out C c)")); 4603var arrow = SyntaxFactory.ArrowExpressionClause(SyntaxFactory.ParseExpression(@" 4636var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"(M(out C c))")); 4667var newInitializer = SyntaxFactory.ConstructorInitializer(SyntaxKind.ThisConstructorInitializer, SyntaxFactory.ParseArgumentList(@"( 4698var expression = SyntaxFactory.ParseExpression(@"M(out C c)"); 4908var newBody = SyntaxFactory.ParseStatement("Prop.ToString();");

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

17477private static string UnaryOperatorName(string op, bool isChecked = false) => OperatorFacts.UnaryOperatorNameFromSyntaxKindIfAny(SyntaxFactory.ParseToken(op).Kind(), isChecked: isChecked); 17479op 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);

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

10321=> SyntaxFactory.IdentifierName(SyntaxFactory.Identifier("Identifier")); 10324=> SyntaxFactory.QualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10327=> SyntaxFactory.GenericName(SyntaxFactory.Identifier("Identifier"), GenerateTypeArgumentList()); 10330=> SyntaxFactory.TypeArgumentList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10333=> SyntaxFactory.AliasQualifiedName(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonColonToken), GenerateIdentifierName()); 10336=> SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)); 10339=> SyntaxFactory.ArrayType(GenerateIdentifierName(), new SyntaxList<ArrayRankSpecifierSyntax>()); 10342=> SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10345=> SyntaxFactory.PointerType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.AsteriskToken)); 10348=> SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(FunctionPointerCallingConventionSyntax), GenerateFunctionPointerParameterList()); 10351=> SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<FunctionPointerParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10354=> SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionListSyntax)); 10357=> SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<FunctionPointerUnmanagedCallingConventionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10360=> SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("Name")); 10363=> SyntaxFactory.NullableType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken)); 10366=> SyntaxFactory.TupleType(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<TupleElementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10369=> SyntaxFactory.TupleElement(GenerateIdentifierName(), default(SyntaxToken)); 10372=> SyntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 10375=> SyntaxFactory.RefType(SyntaxFactory.Token(SyntaxKind.RefKeyword), default(SyntaxToken), GenerateIdentifierName()); 10378=> SyntaxFactory.ScopedType(SyntaxFactory.Token(SyntaxKind.ScopedKeyword), GenerateIdentifierName()); 10381=> SyntaxFactory.ParenthesizedExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10384=> SyntaxFactory.TupleExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10387=> SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryPlusExpression, SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10390=> SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), GenerateIdentifierName()); 10393=> SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusPlusToken)); 10396=> SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10399=> SyntaxFactory.ConditionalAccessExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName()); 10402=> SyntaxFactory.MemberBindingExpression(SyntaxFactory.Token(SyntaxKind.DotToken), GenerateIdentifierName()); 10405=> SyntaxFactory.ElementBindingExpression(GenerateBracketedArgumentList()); 10408=> SyntaxFactory.RangeExpression(default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.DotDotToken), default(ExpressionSyntax)); 10411=> SyntaxFactory.ImplicitElementAccess(GenerateBracketedArgumentList()); 10414=> SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.PlusToken), GenerateIdentifierName()); 10417=> SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10420=> SyntaxFactory.ConditionalExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateIdentifierName()); 10423=> SyntaxFactory.ThisExpression(SyntaxFactory.Token(SyntaxKind.ThisKeyword)); 10426=> SyntaxFactory.BaseExpression(SyntaxFactory.Token(SyntaxKind.BaseKeyword)); 10429=> SyntaxFactory.LiteralExpression(SyntaxKind.ArgListExpression, SyntaxFactory.Token(SyntaxKind.ArgListKeyword)); 10432=> SyntaxFactory.FieldExpression(SyntaxFactory.Token(SyntaxKind.FieldKeyword)); 10435=> SyntaxFactory.MakeRefExpression(SyntaxFactory.Token(SyntaxKind.MakeRefKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10438=> SyntaxFactory.RefTypeExpression(SyntaxFactory.Token(SyntaxKind.RefTypeKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10441=> SyntaxFactory.RefValueExpression(SyntaxFactory.Token(SyntaxKind.RefValueKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CommaToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10444=> SyntaxFactory.CheckedExpression(SyntaxKind.CheckedExpression, SyntaxFactory.Token(SyntaxKind.CheckedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10447=> SyntaxFactory.DefaultExpression(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10450=> SyntaxFactory.TypeOfExpression(SyntaxFactory.Token(SyntaxKind.TypeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10453=> SyntaxFactory.SizeOfExpression(SyntaxFactory.Token(SyntaxKind.SizeOfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10456=> SyntaxFactory.InvocationExpression(GenerateIdentifierName(), GenerateArgumentList()); 10459=> SyntaxFactory.ElementAccessExpression(GenerateIdentifierName(), GenerateBracketedArgumentList()); 10462=> SyntaxFactory.ArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10465=> SyntaxFactory.BracketedArgumentList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10468=> SyntaxFactory.Argument(default(NameColonSyntax), default(SyntaxToken), GenerateIdentifierName()); 10471=> SyntaxFactory.ExpressionColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10474=> SyntaxFactory.NameColon(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10477=> SyntaxFactory.DeclarationExpression(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10480=> SyntaxFactory.CastExpression(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateIdentifierName()); 10483=> SyntaxFactory.AnonymousMethodExpression(new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.DelegateKeyword), default(ParameterListSyntax), GenerateBlock(), default(ExpressionSyntax)); 10486=> SyntaxFactory.SimpleLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateParameter(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10489=> SyntaxFactory.RefExpression(SyntaxFactory.Token(SyntaxKind.RefKeyword), GenerateIdentifierName()); 10492=> SyntaxFactory.ParenthesizedLambdaExpression(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), GenerateParameterList(), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), default(BlockSyntax), default(ExpressionSyntax)); 10495=> SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<ExpressionSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10498=> SyntaxFactory.ImplicitObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArgumentList(), default(InitializerExpressionSyntax)); 10501=> SyntaxFactory.ObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateIdentifierName(), default(ArgumentListSyntax), default(InitializerExpressionSyntax)); 10504=> SyntaxFactory.WithExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.WithKeyword), GenerateInitializerExpression()); 10507=> SyntaxFactory.AnonymousObjectMemberDeclarator(default(NameEqualsSyntax), GenerateIdentifierName()); 10510=> SyntaxFactory.AnonymousObjectCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<AnonymousObjectMemberDeclaratorSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10513=> SyntaxFactory.ArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), GenerateArrayType(), default(InitializerExpressionSyntax)); 10516=> SyntaxFactory.ImplicitArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10519=> SyntaxFactory.StackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), GenerateIdentifierName(), default(InitializerExpressionSyntax)); 10522=> SyntaxFactory.ImplicitStackAllocArrayCreationExpression(SyntaxFactory.Token(SyntaxKind.StackAllocKeyword), SyntaxFactory.Token(SyntaxKind.OpenBracketToken), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), GenerateInitializerExpression()); 10525=> SyntaxFactory.CollectionExpression(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<CollectionElementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10528=> SyntaxFactory.ExpressionElement(GenerateIdentifierName()); 10531=> SyntaxFactory.SpreadElement(SyntaxFactory.Token(SyntaxKind.DotDotToken), GenerateIdentifierName()); 10534=> SyntaxFactory.QueryExpression(GenerateFromClause(), GenerateQueryBody()); 10537=> SyntaxFactory.QueryBody(new SyntaxList<QueryClauseSyntax>(), GenerateSelectClause(), default(QueryContinuationSyntax)); 10540=> SyntaxFactory.FromClause(SyntaxFactory.Token(SyntaxKind.FromKeyword), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.InKeyword), GenerateIdentifierName()); 10543=> SyntaxFactory.LetClause(SyntaxFactory.Token(SyntaxKind.LetKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10546=> 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)); 10549=> SyntaxFactory.JoinIntoClause(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier")); 10552=> SyntaxFactory.WhereClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName()); 10555=> SyntaxFactory.OrderByClause(SyntaxFactory.Token(SyntaxKind.OrderByKeyword), new SeparatedSyntaxList<OrderingSyntax>()); 10558=> SyntaxFactory.Ordering(SyntaxKind.AscendingOrdering, GenerateIdentifierName(), default(SyntaxToken)); 10561=> SyntaxFactory.SelectClause(SyntaxFactory.Token(SyntaxKind.SelectKeyword), GenerateIdentifierName()); 10564=> SyntaxFactory.GroupClause(SyntaxFactory.Token(SyntaxKind.GroupKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ByKeyword), GenerateIdentifierName()); 10567=> SyntaxFactory.QueryContinuation(SyntaxFactory.Token(SyntaxKind.IntoKeyword), SyntaxFactory.Identifier("Identifier"), GenerateQueryBody()); 10570=> SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 10573=> SyntaxFactory.InterpolatedStringExpression(SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), new SyntaxList<InterpolatedStringContentSyntax>(), SyntaxFactory.Token(SyntaxKind.InterpolatedStringEndToken)); 10576=> SyntaxFactory.IsPatternExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.IsKeyword), GenerateDiscardPattern()); 10579=> SyntaxFactory.ThrowExpression(SyntaxFactory.Token(SyntaxKind.ThrowKeyword), GenerateIdentifierName()); 10582=> SyntaxFactory.WhenClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), GenerateIdentifierName()); 10585=> SyntaxFactory.DiscardPattern(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10588=> SyntaxFactory.DeclarationPattern(GenerateIdentifierName(), GenerateSingleVariableDesignation()); 10591=> SyntaxFactory.VarPattern(SyntaxFactory.Token(SyntaxKind.VarKeyword), GenerateSingleVariableDesignation()); 10594=> SyntaxFactory.RecursivePattern(default(TypeSyntax), default(PositionalPatternClauseSyntax), default(PropertyPatternClauseSyntax), default(VariableDesignationSyntax)); 10597=> SyntaxFactory.PositionalPatternClause(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10600=> SyntaxFactory.PropertyPatternClause(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SubpatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10603=> SyntaxFactory.Subpattern(default(BaseExpressionColonSyntax), GenerateDiscardPattern()); 10606=> SyntaxFactory.ConstantPattern(GenerateIdentifierName()); 10609=> SyntaxFactory.ParenthesizedPattern(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10612=> SyntaxFactory.RelationalPattern(SyntaxFactory.Token(SyntaxKind.EqualsEqualsToken), GenerateIdentifierName()); 10615=> SyntaxFactory.TypePattern(GenerateIdentifierName()); 10618=> SyntaxFactory.BinaryPattern(SyntaxKind.OrPattern, GenerateDiscardPattern(), SyntaxFactory.Token(SyntaxKind.OrKeyword), GenerateDiscardPattern()); 10621=> SyntaxFactory.UnaryPattern(SyntaxFactory.Token(SyntaxKind.NotKeyword), GenerateDiscardPattern()); 10624=> SyntaxFactory.ListPattern(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<PatternSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken), default(VariableDesignationSyntax)); 10627=> SyntaxFactory.SlicePattern(SyntaxFactory.Token(SyntaxKind.DotDotToken), default(PatternSyntax)); 10630=> SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10633=> SyntaxFactory.Interpolation(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), GenerateIdentifierName(), default(InterpolationAlignmentClauseSyntax), default(InterpolationFormatClauseSyntax), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10636=> SyntaxFactory.InterpolationAlignmentClause(SyntaxFactory.Identifier("CommaToken"), GenerateIdentifierName()); 10639=> SyntaxFactory.InterpolationFormatClause(SyntaxFactory.Identifier("ColonToken"), SyntaxFactory.Token(SyntaxKind.InterpolatedStringTextToken)); 10642=> SyntaxFactory.GlobalStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateBlock()); 10645=> SyntaxFactory.Block(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<StatementSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10648=> SyntaxFactory.LocalFunctionStatement(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), SyntaxFactory.Identifier("Identifier"), default(TypeParameterListSyntax), GenerateParameterList(), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10651=> SyntaxFactory.LocalDeclarationStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), default(SyntaxToken), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10654=> SyntaxFactory.VariableDeclaration(GenerateIdentifierName(), new SeparatedSyntaxList<VariableDeclaratorSyntax>()); 10657=> SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("Identifier"), default(BracketedArgumentListSyntax), default(EqualsValueClauseSyntax)); 10660=> SyntaxFactory.EqualsValueClause(SyntaxFactory.Token(SyntaxKind.EqualsToken), GenerateIdentifierName()); 10663=> SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("Identifier")); 10666=> SyntaxFactory.DiscardDesignation(SyntaxFactory.Token(SyntaxKind.UnderscoreToken)); 10669=> SyntaxFactory.ParenthesizedVariableDesignation(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<VariableDesignationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10672=> SyntaxFactory.ExpressionStatement(new SyntaxList<AttributeListSyntax>(), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10675=> SyntaxFactory.EmptyStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10678=> SyntaxFactory.LabeledStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken), GenerateBlock()); 10681=> SyntaxFactory.GotoStatement(SyntaxKind.GotoStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.GotoKeyword), default(SyntaxToken), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10684=> SyntaxFactory.BreakStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.BreakKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10687=> SyntaxFactory.ContinueStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ContinueKeyword), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10690=> SyntaxFactory.ReturnStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10693=> SyntaxFactory.ThrowStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.ThrowKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10696=> SyntaxFactory.YieldStatement(SyntaxKind.YieldReturnStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.YieldKeyword), SyntaxFactory.Token(SyntaxKind.ReturnKeyword), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10699=> SyntaxFactory.WhileStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.WhileKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10702=> 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)); 10705=> 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()); 10708=> 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()); 10711=> 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()); 10714=> SyntaxFactory.UsingStatement(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), default(VariableDeclarationSyntax), default(ExpressionSyntax), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10717=> SyntaxFactory.FixedStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.FixedKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10720=> SyntaxFactory.CheckedStatement(SyntaxKind.CheckedStatement, new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.CheckedKeyword), GenerateBlock()); 10723=> SyntaxFactory.UnsafeStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.UnsafeKeyword), GenerateBlock()); 10726=> SyntaxFactory.LockStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.LockKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock()); 10729=> SyntaxFactory.IfStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.IfKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken), GenerateBlock(), default(ElseClauseSyntax)); 10732=> SyntaxFactory.ElseClause(SyntaxFactory.Token(SyntaxKind.ElseKeyword), GenerateBlock()); 10735=> 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)); 10738=> SyntaxFactory.SwitchSection(new SyntaxList<SwitchLabelSyntax>(), new SyntaxList<StatementSyntax>()); 10741=> SyntaxFactory.CasePatternSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10744=> SyntaxFactory.CaseSwitchLabel(SyntaxFactory.Token(SyntaxKind.CaseKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10747=> SyntaxFactory.DefaultSwitchLabel(SyntaxFactory.Token(SyntaxKind.DefaultKeyword), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10750=> SyntaxFactory.SwitchExpression(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SwitchKeyword), SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SeparatedSyntaxList<SwitchExpressionArmSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10753=> SyntaxFactory.SwitchExpressionArm(GenerateDiscardPattern(), default(WhenClauseSyntax), SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10756=> SyntaxFactory.TryStatement(new SyntaxList<AttributeListSyntax>(), SyntaxFactory.Token(SyntaxKind.TryKeyword), GenerateBlock(), new SyntaxList<CatchClauseSyntax>(), default(FinallyClauseSyntax)); 10759=> SyntaxFactory.CatchClause(SyntaxFactory.Token(SyntaxKind.CatchKeyword), default(CatchDeclarationSyntax), default(CatchFilterClauseSyntax), GenerateBlock()); 10762=> SyntaxFactory.CatchDeclaration(SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10765=> SyntaxFactory.CatchFilterClause(SyntaxFactory.Token(SyntaxKind.WhenKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10768=> SyntaxFactory.FinallyClause(SyntaxFactory.Token(SyntaxKind.FinallyKeyword), GenerateBlock()); 10771=> SyntaxFactory.CompilationUnit(new SyntaxList<ExternAliasDirectiveSyntax>(), new SyntaxList<UsingDirectiveSyntax>(), new SyntaxList<AttributeListSyntax>(), new SyntaxList<MemberDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfFileToken)); 10774=> SyntaxFactory.ExternAliasDirective(SyntaxFactory.Token(SyntaxKind.ExternKeyword), SyntaxFactory.Token(SyntaxKind.AliasKeyword), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10777=> SyntaxFactory.UsingDirective(default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.UsingKeyword), default(SyntaxToken), default(SyntaxToken), default(NameEqualsSyntax), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10780=> 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)); 10783=> 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>()); 10786=> SyntaxFactory.AttributeList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), default(AttributeTargetSpecifierSyntax), new SeparatedSyntaxList<AttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10789=> SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10792=> SyntaxFactory.Attribute(GenerateIdentifierName(), default(AttributeArgumentListSyntax)); 10795=> SyntaxFactory.AttributeArgumentList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<AttributeArgumentSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10798=> SyntaxFactory.AttributeArgument(default(NameEqualsSyntax), default(NameColonSyntax), GenerateIdentifierName()); 10801=> SyntaxFactory.NameEquals(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EqualsToken)); 10804=> SyntaxFactory.TypeParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList<TypeParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10807=> SyntaxFactory.TypeParameter(new SyntaxList<AttributeListSyntax>(), default(SyntaxToken), SyntaxFactory.Identifier("Identifier")); 10810=> 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)); 10813=> 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)); 10816=> 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)); 10819=> 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)); 10822=> 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)); 10825=> 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)); 10828=> SyntaxFactory.EnumMemberDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); 10831=> SyntaxFactory.ExtensionDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.ExtensionKeyword), default(TypeParameterListSyntax), default(ParameterListSyntax), new SyntaxList<TypeParameterConstraintClauseSyntax>(), default(SyntaxToken), new SyntaxList<MemberDeclarationSyntax>(), default(SyntaxToken), default(SyntaxToken)); 10834=> SyntaxFactory.BaseList(SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<BaseTypeSyntax>()); 10837=> SyntaxFactory.SimpleBaseType(GenerateIdentifierName()); 10840=> SyntaxFactory.PrimaryConstructorBaseType(GenerateIdentifierName(), GenerateArgumentList()); 10843=> SyntaxFactory.TypeParameterConstraintClause(SyntaxFactory.Token(SyntaxKind.WhereKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.ColonToken), new SeparatedSyntaxList<TypeParameterConstraintSyntax>()); 10846=> SyntaxFactory.ConstructorConstraint(SyntaxFactory.Token(SyntaxKind.NewKeyword), SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10849=> SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint, SyntaxFactory.Token(SyntaxKind.ClassKeyword), default(SyntaxToken)); 10852=> SyntaxFactory.TypeConstraint(GenerateIdentifierName()); 10855=> SyntaxFactory.DefaultConstraint(SyntaxFactory.Token(SyntaxKind.DefaultKeyword)); 10858=> SyntaxFactory.AllowsConstraintClause(SyntaxFactory.Token(SyntaxKind.AllowsKeyword), new SeparatedSyntaxList<AllowsConstraintSyntax>()); 10861=> SyntaxFactory.RefStructConstraint(SyntaxFactory.Token(SyntaxKind.RefKeyword), SyntaxFactory.Token(SyntaxKind.StructKeyword)); 10864=> SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10867=> SyntaxFactory.EventFieldDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateVariableDeclaration(), SyntaxFactory.Token(SyntaxKind.SemicolonToken)); 10870=> SyntaxFactory.ExplicitInterfaceSpecifier(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken)); 10873=> 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)); 10876=> 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)); 10879=> 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)); 10882=> SyntaxFactory.ConstructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(ConstructorInitializerSyntax), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10885=> SyntaxFactory.ConstructorInitializer(SyntaxKind.BaseConstructorInitializer, SyntaxFactory.Token(SyntaxKind.ColonToken), SyntaxFactory.Token(SyntaxKind.BaseKeyword), GenerateArgumentList()); 10888=> SyntaxFactory.DestructorDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.TildeToken), SyntaxFactory.Identifier("Identifier"), GenerateParameterList(), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10891=> SyntaxFactory.PropertyDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(EqualsValueClauseSyntax), default(SyntaxToken)); 10894=> SyntaxFactory.ArrowExpressionClause(SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), GenerateIdentifierName()); 10897=> SyntaxFactory.EventDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.EventKeyword), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Identifier("Identifier"), default(AccessorListSyntax), default(SyntaxToken)); 10900=> SyntaxFactory.IndexerDeclaration(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName(), default(ExplicitInterfaceSpecifierSyntax), SyntaxFactory.Token(SyntaxKind.ThisKeyword), GenerateBracketedParameterList(), default(AccessorListSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10903=> SyntaxFactory.AccessorList(SyntaxFactory.Token(SyntaxKind.OpenBraceToken), new SyntaxList<AccessorDeclarationSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBraceToken)); 10906=> SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.GetKeyword), default(BlockSyntax), default(ArrowExpressionClauseSyntax), default(SyntaxToken)); 10909=> SyntaxFactory.ParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10912=> SyntaxFactory.BracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<ParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10915=> SyntaxFactory.Parameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax), default(SyntaxToken), default(EqualsValueClauseSyntax)); 10918=> SyntaxFactory.FunctionPointerParameter(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), GenerateIdentifierName()); 10921=> SyntaxFactory.IncompleteMember(new SyntaxList<AttributeListSyntax>(), new SyntaxTokenList(), default(TypeSyntax)); 10924=> SyntaxFactory.SkippedTokensTrivia(new SyntaxTokenList()); 10927=> SyntaxFactory.DocumentationCommentTrivia(SyntaxKind.SingleLineDocumentationCommentTrivia, new SyntaxList<XmlNodeSyntax>(), SyntaxFactory.Token(SyntaxKind.EndOfDocumentationCommentToken)); 10930=> SyntaxFactory.TypeCref(GenerateIdentifierName()); 10933=> SyntaxFactory.QualifiedCref(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.DotToken), GenerateNameMemberCref()); 10936=> SyntaxFactory.NameMemberCref(GenerateIdentifierName(), default(CrefParameterListSyntax)); 10939=> SyntaxFactory.IndexerMemberCref(SyntaxFactory.Token(SyntaxKind.ThisKeyword), default(CrefBracketedParameterListSyntax)); 10942=> SyntaxFactory.OperatorMemberCref(SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.PlusToken), default(CrefParameterListSyntax)); 10945=> SyntaxFactory.ConversionOperatorMemberCref(SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), SyntaxFactory.Token(SyntaxKind.OperatorKeyword), default(SyntaxToken), GenerateIdentifierName(), default(CrefParameterListSyntax)); 10948=> SyntaxFactory.CrefParameterList(SyntaxFactory.Token(SyntaxKind.OpenParenToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 10951=> SyntaxFactory.CrefBracketedParameterList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList<CrefParameterSyntax>(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); 10954=> SyntaxFactory.CrefParameter(default(SyntaxToken), default(SyntaxToken), GenerateIdentifierName()); 10957=> SyntaxFactory.XmlElement(GenerateXmlElementStartTag(), new SyntaxList<XmlNodeSyntax>(), GenerateXmlElementEndTag()); 10960=> SyntaxFactory.XmlElementStartTag(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10963=> SyntaxFactory.XmlElementEndTag(SyntaxFactory.Token(SyntaxKind.LessThanSlashToken), GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); 10966=> SyntaxFactory.XmlEmptyElement(SyntaxFactory.Token(SyntaxKind.LessThanToken), GenerateXmlName(), new SyntaxList<XmlAttributeSyntax>(), SyntaxFactory.Token(SyntaxKind.SlashGreaterThanToken)); 10969=> SyntaxFactory.XmlName(default(XmlPrefixSyntax), SyntaxFactory.Identifier("LocalName")); 10972=> SyntaxFactory.XmlPrefix(SyntaxFactory.Identifier("Prefix"), SyntaxFactory.Token(SyntaxKind.ColonToken)); 10975=> SyntaxFactory.XmlTextAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10978=> SyntaxFactory.XmlCrefAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateTypeCref(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10981=> SyntaxFactory.XmlNameAttribute(GenerateXmlName(), SyntaxFactory.Token(SyntaxKind.EqualsToken), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.SingleQuoteToken)); 10984=> SyntaxFactory.XmlText(new SyntaxTokenList()); 10987=> SyntaxFactory.XmlCDataSection(SyntaxFactory.Token(SyntaxKind.XmlCDataStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCDataEndToken)); 10990=> SyntaxFactory.XmlProcessingInstruction(SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionStartToken), GenerateXmlName(), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlProcessingInstructionEndToken)); 10993=> SyntaxFactory.XmlComment(SyntaxFactory.Token(SyntaxKind.XmlCommentStartToken), new SyntaxTokenList(), SyntaxFactory.Token(SyntaxKind.XmlCommentEndToken)); 10996=> SyntaxFactory.IfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.IfKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 10999=> SyntaxFactory.ElifDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElifKeyword), GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool(), new bool()); 11002=> SyntaxFactory.ElseDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ElseKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool(), new bool()); 11005=> SyntaxFactory.EndIfDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndIfKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11008=> SyntaxFactory.RegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.RegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11011=> SyntaxFactory.EndRegionDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.EndRegionKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11014=> SyntaxFactory.ErrorDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ErrorKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11017=> SyntaxFactory.WarningDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.WarningKeyword), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11020=> SyntaxFactory.BadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Identifier("Identifier"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11023=> SyntaxFactory.DefineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.DefineKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11026=> SyntaxFactory.UndefDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.UndefKeyword), SyntaxFactory.Identifier("Name"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11029=> SyntaxFactory.LineDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LineKeyword), SyntaxFactory.Literal("1", 1), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11032=> SyntaxFactory.LineDirectivePosition(SyntaxFactory.Token(SyntaxKind.OpenParenToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Literal("1", 1), SyntaxFactory.Token(SyntaxKind.CloseParenToken)); 11035=> 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()); 11038=> 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()); 11041=> 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()); 11044=> SyntaxFactory.ReferenceDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ReferenceKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11047=> SyntaxFactory.LoadDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.LoadKeyword), SyntaxFactory.Literal("string", "string"), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11050=> SyntaxFactory.ShebangDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ExclamationToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11053=> SyntaxFactory.IgnoredDirectiveTrivia(SyntaxFactory.Token(SyntaxKind.HashToken), SyntaxFactory.Token(SyntaxKind.ColonToken), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken), new bool()); 11056=> 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());

32return SyntaxFactory.ParseSyntaxTree(itext, options); 39return SyntaxFactory.ParseSyntaxTree(itext, options); 191var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 209var interfaceKeyword = SyntaxFactory.ParseToken("struct"); // prime the memoizer 439var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 461var oldTree = SyntaxFactory.ParseSyntaxTree(text, options: TestOptions.Script); 489var tree = SyntaxFactory.ParseSyntaxTree(source); 499var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 521var tree = SyntaxFactory.ParseSyntaxTree(source); 531var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 561var tree = SyntaxFactory.ParseSyntaxTree(source); 578var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 612var initialTree = SyntaxFactory.ParseSyntaxTree(initialSource); 842var fullTree = SyntaxFactory.ParseSyntaxTree(withCloseBraceDeletedText.ToString()); 1343var startTree = SyntaxFactory.ParseSyntaxTree(text); 1392var startTree = SyntaxFactory.ParseSyntaxTree(text); 1406var startTree = SyntaxFactory.ParseSyntaxTree(text); 1613SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1634SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1653SyntaxTree syntaxTree = SyntaxFactory.ParseSyntaxTree(startingText); 1859SyntaxTree oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1874var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 1888SyntaxTree origTree = SyntaxFactory.ParseSyntaxTree(oldText); 1896SyntaxTree fullTree = SyntaxFactory.ParseSyntaxTree(newText); 2006var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 2412var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 3175var tree = SyntaxFactory.ParseSyntaxTree(text); 3182var parsedTree = SyntaxFactory.ParseSyntaxTree(text2); 3196var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 3202var parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 3212var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 3225var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 3241var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 3256var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 3271var startTree = SyntaxFactory.ParseSyntaxTree(oldText, options: TestOptions.Script); 3283var parsedTree = SyntaxFactory.ParseSyntaxTree(newText, options: TestOptions.Script); 3326var comp = CSharpTestBase.CreateCompilation(SyntaxFactory.ParseSyntaxTree(String.Empty)); 3336var fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 3350fullTree = SyntaxFactory.ParseSyntaxTree(newIText.ToString(), options: newTree.Options); 3406var currTree = SyntaxFactory.ParseSyntaxTree(text); 3420var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 3446var currTree = SyntaxFactory.ParseSyntaxTree(text); 3456var fullTree = SyntaxFactory.ParseSyntaxTree(currIText.ToString()); 3474var oldTree = SyntaxFactory.ParseSyntaxTree(text); 3483var tempTree = SyntaxFactory.ParseSyntaxTree(text); 3490var oldTree = SyntaxFactory.SyntaxTree(oldRoot, options: tempTree.Options, path: tempTree.FilePath); 3528var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); // f is a simple lambda parameter 3534var fullTree = SyntaxFactory.ParseSyntaxTree(newText); 3546var interfaceKeyword = SyntaxFactory.ParseToken("interface"); // prime the memoizer 3611var oldTree = SyntaxFactory.ParseSyntaxTree(oldText); 3613WalkTreeAndVerify(newTree.GetCompilationUnitRoot(), SyntaxFactory.ParseSyntaxTree(newText).GetCompilationUnitRoot()); 3626var tree = SyntaxFactory.ParseSyntaxTree(source); 3632var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3647var tree = SyntaxFactory.ParseSyntaxTree(src); 3653var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3668var tree = SyntaxFactory.ParseSyntaxTree(source); 3674var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3689var tree = SyntaxFactory.ParseSyntaxTree(source); 3695var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3710var tree = SyntaxFactory.ParseSyntaxTree(source); 3716var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3731var tree = SyntaxFactory.ParseSyntaxTree(source); 3738var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3755var tree = SyntaxFactory.ParseSyntaxTree(source); 3762var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3779var tree = SyntaxFactory.ParseSyntaxTree(source); 3786var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3803var tree = SyntaxFactory.ParseSyntaxTree(source); 3810var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3827var tree = SyntaxFactory.ParseSyntaxTree(source); 3834var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3851var tree = SyntaxFactory.ParseSyntaxTree(source); 3858var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3877var tree = SyntaxFactory.ParseSyntaxTree(source); 3884var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3903var tree = SyntaxFactory.ParseSyntaxTree(source); 3909var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3928var tree = SyntaxFactory.ParseSyntaxTree(source); 3935var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3954var tree = SyntaxFactory.ParseSyntaxTree(source); 3961var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3972var tree = SyntaxFactory.ParseSyntaxTree(source); 3979var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 3990var tree = SyntaxFactory.ParseSyntaxTree(source); 3997var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4008var tree = SyntaxFactory.ParseSyntaxTree(source); 4015var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4023var tree = SyntaxFactory.ParseSyntaxTree(source); 4029var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4037var tree = SyntaxFactory.ParseSyntaxTree(source); 4043var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4051var tree = SyntaxFactory.ParseSyntaxTree(source); 4058var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4089var tree = SyntaxFactory.ParseSyntaxTree(source); 4095var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4110var tree = SyntaxFactory.ParseSyntaxTree(source); 4132var fullTree = SyntaxFactory.ParseSyntaxTree(text.ToString()); 4161var tree = SyntaxFactory.ParseSyntaxTree(oldText); 4163parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 4169var tree = SyntaxFactory.ParseSyntaxTree(oldText); 4171parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 4190var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 4196parsedTree = SyntaxFactory.ParseSyntaxTree(newText); 4201var startTree = SyntaxFactory.ParseSyntaxTree(oldText); 4204parsedTree = 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);

106var root = SyntaxFactory.ParseCompilationUnit(source, options: TestOptions.Regular.WithFeature(FeatureName)); 128var root = SyntaxFactory.ParseCompilationUnit(source, options: TestOptions.Regular.WithFeature(FeatureName)); 148var root = SyntaxFactory.ParseCompilationUnit("#!abc", options: TestOptions.Regular.WithFeature(FeatureName)); 152var xyz = SyntaxFactory.Token(default, SyntaxKind.StringLiteralToken, "xyz", "xyz", default); 153var ijk = SyntaxFactory.Token(default, SyntaxKind.StringLiteralToken, "ijk", "ijk", default);

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

17return SyntaxFactory.ParseSyntaxTree(text, options: options); 22return 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);

26return SyntaxFactory.ParseSyntaxTree(text, options: options); 31return SyntaxFactory.ParseExpression(text, options: options);

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

80protected virtual SyntaxTree ParseTree(string text, CSharpParseOptions? options) => SyntaxFactory.ParseSyntaxTree(text, options); 83SyntaxFactory.ParseCompilationUnit(text, options: parseOptions); 98var node = SyntaxFactory.ParseStatement(text, options: options); 110var node = SyntaxFactory.ParseMemberDeclaration(text, offset, options, consumeFullText); 125UsingNode(text, SyntaxFactory.ParseExpression(text, options: options), expectedErrors); 485_ = 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();