1 write to _syntaxFactory
Microsoft.CodeAnalysis.CSharp (1)
Parser\LanguageParser.cs (1)
46
_syntaxFactory
= new ContextAwareSyntax(_syntaxFactoryContext);
298 references to _syntaxFactory
Microsoft.CodeAnalysis.CSharp (298)
Parser\LanguageParser.cs (269)
190
var result =
_syntaxFactory
.CompilationUnit(body.Externs, body.Usings, body.Attributes, body.Members, eof);
230
var fileAsTrivia =
_syntaxFactory
.SkippedTokensTrivia(builder.ToList<SyntaxToken>());
295
return
_syntaxFactory
.FileScopedNamespaceDeclaration(
311
return
_syntaxFactory
.NamespaceDeclaration(
934
return
_syntaxFactory
.ExternAliasDirective(
944
return
_syntaxFactory
.NameEquals(
945
_syntaxFactory
.IdentifierName(this.ParseIdentifierToken()),
1016
return
_syntaxFactory
.UsingDirective(globalToken, usingToken, staticToken, unsafeToken, alias, type, semicolon);
1126
?
_syntaxFactory
.AttributeTargetSpecifier(ConvertToKeyword(this.EatToken()), this.EatToken(SyntaxKind.ColonToken))
1148
return
_syntaxFactory
.AttributeList(openBracket, location, attributes, closeBracket);
1195
return
_syntaxFactory
.Attribute(
1223
return
_syntaxFactory
.AttributeArgumentList(
1272
nameEquals =
_syntaxFactory
.NameEquals(
1273
_syntaxFactory
.IdentifierName(this.ParseIdentifierToken()),
1278
nameColon =
_syntaxFactory
.NameColon(
1286
return
_syntaxFactory
.AttributeArgument(
1851
return constructTypeDeclaration(
_syntaxFactory
, attributes, modifiers, keyword, recordModifier, name, typeParameters, paramList, baseList, constraints, openBrace, members, closeBrace, semicolon);
2103
?
_syntaxFactory
.PrimaryConstructorBaseType(firstType, this.ParseParenthesizedArgumentList())
2104
:
_syntaxFactory
.SimpleBaseType(firstType));
2118
list.Add(
_syntaxFactory
.SimpleBaseType(this.ParseType()));
2137
list.Add(
_syntaxFactory
.SimpleBaseType(this.ParseType()));
2147
return
_syntaxFactory
.BaseList(colon, _pool.ToListAndFree(list));
2188
bounds.Add(
_syntaxFactory
.TypeConstraint(this.AddError(this.CreateMissingIdentifierName(), ErrorCode.ERR_TypeExpected)));
2220
bounds.Add(
_syntaxFactory
.TypeConstraint(this.AddError(this.CreateMissingIdentifierName(), ErrorCode.ERR_TypeExpected)));
2236
return
_syntaxFactory
.TypeParameterConstraintClause(
2275
_syntaxFactory
.ConstructorConstraint(
2281
_syntaxFactory
.ClassOrStructConstraint(
2289
_syntaxFactory
.ClassOrStructConstraint(
2295
_syntaxFactory
.DefaultConstraint(defaultKeyword: this.EatToken()),
2298
_syntaxFactory
.TypeConstraint(AddTrailingSkippedSyntax(
2306
?
_syntaxFactory
.TypeConstraint(this.ParseType())
2307
:
_syntaxFactory
.TypeConstraint(AddTrailingSkippedSyntax(
2326
_syntaxFactory
.RefStructConstraint(
2339
return
_syntaxFactory
.AllowsConstraintClause(allows, _pool.ToListAndFree(bounds));
2342
return
_syntaxFactory
.TypeConstraint(this.ParseType());
2492
return @this.
_syntaxFactory
.IncompleteMember(
2566
return
_syntaxFactory
.GlobalStatement(ParseUnsafeStatement(attributes));
2573
return
_syntaxFactory
.GlobalStatement(ParseFixedStatement(attributes));
2582
return
_syntaxFactory
.GlobalStatement(ParseExpressionStatement(attributes));
2589
return
_syntaxFactory
.GlobalStatement(ParseExpressionStatement(attributes));
2619
var voidType =
_syntaxFactory
.PredefinedType(
2714
return
_syntaxFactory
.GlobalStatement(statement);
2861
result =
_syntaxFactory
.GlobalStatement(declaration);
2889
result =
_syntaxFactory
.GlobalStatement(statement);
2971
result =
_syntaxFactory
.IncompleteMember(attributes, modifiers.ToList(), type);
2992
var incompleteMember =
_syntaxFactory
.IncompleteMember(attributes, modifiers.ToList(), type.IsMissing ? null : type);
3368
return
_syntaxFactory
.ConstructorDeclaration(attributes, modifiers.ToList(), name, paramList, initializer, body, expressionBody, semicolon);
3400
:
_syntaxFactory
.ArgumentList(
3405
return
_syntaxFactory
.ConstructorInitializer(kind, colon, token, argumentList);
3414
var parameterList =
_syntaxFactory
.ParameterList(
3422
return
_syntaxFactory
.DestructorDeclaration(attributes, modifiers.ToList(), tilde, name, parameterList, body, expressionBody, semicolon);
3563
return
_syntaxFactory
.MethodDeclaration(
3704
return
_syntaxFactory
.ConversionOperatorDeclaration(
3712
_syntaxFactory
.ParameterList(
3743
return
_syntaxFactory
.ConversionOperatorDeclaration(
3823
return
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
4026
return
_syntaxFactory
.OperatorDeclaration(
4088
return
_syntaxFactory
.IndexerDeclaration(
4144
initializer =
_syntaxFactory
.EqualsValueClause(equals, value: value);
4157
return
_syntaxFactory
.PropertyDeclaration(
4225
return
_syntaxFactory
.AccessorList(
4233
return
_syntaxFactory
.ArrowExpressionClause(
4246
return refKeyword == null ? expression :
_syntaxFactory
.RefExpression(refKeyword, expression);
4557
return
_syntaxFactory
.AccessorDeclaration(
4594
return
_syntaxFactory
.ParameterList(open, parameters, close);
4605
return
_syntaxFactory
.BracketedParameterList(open, parameters, close);
4789
return
_syntaxFactory
.Parameter(
4818
return
_syntaxFactory
.Parameter(
4823
equalsToken == null ? null :
_syntaxFactory
.EqualsValueClause(equalsToken, this.ParseExpressionCore()));
4892
return
_syntaxFactory
.FieldDeclaration(
4894
_syntaxFactory
.VariableDeclaration(
4931
return
_syntaxFactory
.EventDeclaration(
4940
_syntaxFactory
.AccessorList(
4989
var decl =
_syntaxFactory
.EventDeclaration(
5028
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
5032
return
_syntaxFactory
.FieldDeclaration(
5035
_syntaxFactory
.VariableDeclaration(type, variables),
5066
return
_syntaxFactory
.EventFieldDeclaration(
5070
_syntaxFactory
.VariableDeclaration(type, variables),
5382
return
_syntaxFactory
.VariableDeclarator(missingIdentifier, null, null);
5431
initializer =
_syntaxFactory
.EqualsValueClause(
5433
refKeyword == null ? init :
_syntaxFactory
.RefExpression(refKeyword, init));
5490
args.Add(
_syntaxFactory
.Argument(null, refKindKeyword: null, expression));
5498
argumentList =
_syntaxFactory
.BracketedArgumentList(open, _pool.ToListAndFree(args), close);
5533
return
_syntaxFactory
.VariableDeclarator(name, argumentList, initializer);
5585
return
_syntaxFactory
.FieldDeclaration(
5588
_syntaxFactory
.VariableDeclaration(
5615
return
_syntaxFactory
.DelegateDeclaration(
5649
tmpList.Add(
_syntaxFactory
.SimpleBaseType(type));
5650
baseList =
_syntaxFactory
.BaseList(
5690
return
_syntaxFactory
.EnumDeclaration(
5724
equalsValue =
_syntaxFactory
.EqualsValueClause(
5731
return
_syntaxFactory
.EnumMemberDeclaration(memberAttrs, modifiers: default, memberName, equalsValue);
5752
return
_syntaxFactory
.IdentifierName(CreateMissingIdentifierToken());
5899
return
_syntaxFactory
.TypeParameterList(
5934
return
_syntaxFactory
.TypeParameter(
5949
return
_syntaxFactory
.TypeParameter(
5982
name =
_syntaxFactory
.GenericName(
5984
_syntaxFactory
.TypeArgumentList(
6329
var omittedTypeArgumentInstance =
_syntaxFactory
.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken));
6645
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(
6660
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
6798
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
6840
return
_syntaxFactory
.QualifiedName(left, separator, right);
6855
return
_syntaxFactory
.QualifiedName(left, separator, right);
6861
identifierLeft =
_syntaxFactory
.IdentifierName(ConvertToKeyword(identifierLeft.Identifier));
6866
return WithAdditionalDiagnostics(
_syntaxFactory
.AliasQualifiedName(identifierLeft, separator, right), left.GetDiagnostics());
7325
return
_syntaxFactory
.PredefinedType(this.EatToken());
7349
return
_syntaxFactory
.RefType(
7402
type =
_syntaxFactory
.NullableType(type, question);
7445
type =
_syntaxFactory
.ArrayType(type, _pool.ToListAndFree(ranks));
7646
var omittedArraySizeExpressionInstance =
_syntaxFactory
.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken));
7697
return
_syntaxFactory
.ArrayRankSpecifier(
7723
list.Add(
_syntaxFactory
.TupleElement(this.CreateMissingIdentifierName(), identifier: null));
7728
list.Add(
_syntaxFactory
.TupleElement(missing, identifier: null));
7731
return
_syntaxFactory
.TupleType(
7739
return
_syntaxFactory
.TupleElement(
7763
return
_syntaxFactory
.PredefinedType(token);
7961
type =
_syntaxFactory
.PointerType(type, this.EatToken());
8130
return
_syntaxFactory
.EmptyStatement(attributes, this.EatToken());
8788
var block =
_syntaxFactory
.Block(
8819
return
_syntaxFactory
.Block(
8963
return
_syntaxFactory
.FixedStatement(
9021
return
_syntaxFactory
.BreakStatement(
9029
return
_syntaxFactory
.ContinueStatement(
9075
finallyClause =
_syntaxFactory
.FinallyClause(
9086
finallyClause =
_syntaxFactory
.FinallyClause(
9091
return
_syntaxFactory
.TryStatement(
9099
=>
_syntaxFactory
.Block(
9135
decl =
_syntaxFactory
.CatchDeclaration(openParen, type, name, closeParen);
9160
filter =
_syntaxFactory
.CatchFilterClause(whenKeyword, openParen, filterExpression, closeParen);
9167
return
_syntaxFactory
.CatchClause(@catch, decl, filter, block);
9204
return
_syntaxFactory
.CheckedStatement(
9224
return
_syntaxFactory
.DoStatement(
9298
var forStatement =
_syntaxFactory
.ForStatement(
9475
return
_syntaxFactory
.ForEachStatement(attributes, awaitTokenOpt, @foreach, openParen, decl.Type, identifier, @in, expression, closeParen, statement);
9479
return
_syntaxFactory
.ForEachVariableStatement(attributes, awaitTokenOpt, @foreach, openParen, variable, @in, expression, closeParen, statement);
9663
return
_syntaxFactory
.GotoStatement(
9712
_syntaxFactory
.ElseClause(
9715
ifStatement =
_syntaxFactory
.IfStatement(
9736
return
_syntaxFactory
.IfStatement(
9750
:
_syntaxFactory
.ElseClause(
9758
return
_syntaxFactory
.LockStatement(
9770
return
_syntaxFactory
.ReturnStatement(
9805
return
_syntaxFactory
.YieldStatement(
9824
return
_syntaxFactory
.SwitchStatement(
9907
label =
_syntaxFactory
.CaseSwitchLabel(
9918
node =
_syntaxFactory
.ConstantPattern(ex);
9925
label =
_syntaxFactory
.CasePatternSwitchLabel(
9933
label =
_syntaxFactory
.CaseSwitchLabel(
9943
label =
_syntaxFactory
.DefaultSwitchLabel(
9957
return
_syntaxFactory
.SwitchSection(
9965
return
_syntaxFactory
.ThrowStatement(
9975
return
_syntaxFactory
.UnsafeStatement(
9993
return
_syntaxFactory
.UsingStatement(
10111
return
_syntaxFactory
.WhileStatement(
10126
return
_syntaxFactory
.LabeledStatement(
10205
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
10222
return
_syntaxFactory
.LocalDeclarationStatement(
10227
_syntaxFactory
.VariableDeclaration(type, variables.ToList()),
10332
result =
_syntaxFactory
.ParenthesizedVariableDesignation(
10352
?
_syntaxFactory
.DiscardDesignation(this.EatContextualToken(SyntaxKind.UnderscoreToken))
10353
:
_syntaxFactory
.SingleVariableDesignation(this.EatToken(SyntaxKind.IdentifierToken));
10363
return
_syntaxFactory
.WhenClause(
10391
return
_syntaxFactory
.VariableDeclaration(
10410
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
10679
return
_syntaxFactory
.LocalFunctionStatement(
10711
return
_syntaxFactory
.ExpressionStatement(attributes, expression, semicolon);
11122
return
_syntaxFactory
.PrefixUnaryExpression(
11133
return
_syntaxFactory
.RangeExpression(
11143
return
_syntaxFactory
.AwaitExpression(
11257
return
_syntaxFactory
.BinaryExpression(
11272
return
_syntaxFactory
.RangeExpression(
11284
return
_syntaxFactory
.BinaryExpression(operatorExpressionKind, leftOperand, operatorToken, this.ParseSubExpression(newPrecedence));
11336
var conditionalExpression =
_syntaxFactory
.ConditionalExpression(
11341
_syntaxFactory
.IdentifierName(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)));
11346
return
_syntaxFactory
.ConditionalExpression(
11495
rhs =
_syntaxFactory
.RefExpression(
11504
return
_syntaxFactory
.AssignmentExpression(
11569
return
_syntaxFactory
.DeclarationExpression(
11570
scopedKeyword == null ? type :
_syntaxFactory
.ScopedType(scopedKeyword, type),
11576
return
_syntaxFactory
.ThrowExpression(
11586
PatternSyntax pattern =>
_syntaxFactory
.IsPatternExpression(leftOperand, opToken, pattern),
11587
TypeSyntax type =>
_syntaxFactory
.BinaryExpression(SyntaxKind.IsExpression, leftOperand, opToken, type),
11659
return
_syntaxFactory
.FieldExpression(this.EatContextualToken(SyntaxKind.FieldKeyword));
11676
return
_syntaxFactory
.ThisExpression(this.EatToken());
11692
return
_syntaxFactory
.LiteralExpression(SyntaxFacts.GetLiteralExpression(tk), this.EatToken());
11723
return this.AddError(
_syntaxFactory
.RefExpression(refKeyword, this.ParseExpressionCore()), ErrorCode.ERR_InvalidExprTerm, SyntaxFacts.GetText(tk));
11733
var expr =
_syntaxFactory
.PredefinedType(this.EatToken());
11773
expr =
_syntaxFactory
.InvocationExpression(expr, this.ParseParenthesizedArgumentList());
11777
expr =
_syntaxFactory
.ElementAccessExpression(expr, this.ParseBracketedArgumentList());
11782
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxFacts.GetPostfixUnaryExpression(this.CurrentToken.Kind), expr, this.EatToken());
11788
expr =
_syntaxFactory
.MemberAccessExpression(
11804
expr =
_syntaxFactory
.MemberAccessExpression(SyntaxKind.PointerMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression));
11821
return
_syntaxFactory
.MemberAccessExpression(
11826
expr =
_syntaxFactory
.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression));
11839
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, this.EatToken());
11852
return
_syntaxFactory
.BaseExpression(this.EatToken());
11967
conditionalAccessExpression =
_syntaxFactory
.ConditionalAccessExpression(
11982
return (questionToken: EatToken(),
_syntaxFactory
.MemberBindingExpression(this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)));
11985
return (questionToken: EatToken(),
_syntaxFactory
.ElementBindingExpression(this.ParseBracketedArgumentList()));
12026
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, EatToken());
12064
=>
_syntaxFactory
.InvocationExpression(expr, this.ParseParenthesizedArgumentList()),
12066
=>
_syntaxFactory
.ElementAccessExpression(expr, this.ParseBracketedArgumentList()),
12068
=>
_syntaxFactory
.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)),
12088
return
_syntaxFactory
.ArgumentList(openToken, arguments, closeToken);
12104
return
_syntaxFactory
.BracketedArgumentList(openToken, arguments, closeToken);
12216
?
_syntaxFactory
.NameColon(
12253
return
_syntaxFactory
.Argument(nameColon, refKindKeyword, expression);
12258
return
_syntaxFactory
.TypeOfExpression(
12270
return
_syntaxFactory
.DefaultExpression(
12278
return
_syntaxFactory
.LiteralExpression(SyntaxKind.DefaultLiteralExpression, keyword);
12284
return
_syntaxFactory
.SizeOfExpression(
12293
return
_syntaxFactory
.MakeRefExpression(
12302
return
_syntaxFactory
.RefTypeExpression(
12315
return
_syntaxFactory
.CheckedExpression(
12325
return
_syntaxFactory
.RefValueExpression(
12467
return
_syntaxFactory
.CastExpression(
12485
_syntaxFactory
.Argument(nameColon: null, refKindKeyword: null, expression));
12493
_syntaxFactory
.Argument(
12494
_syntaxFactory
.NameColon((IdentifierNameSyntax)expression, EatToken()),
12499
return
_syntaxFactory
.ParenthesizedExpression(
12516
?
_syntaxFactory
.Argument(nameColon: null, refKindKeyword: null, expression: expression)
12517
:
_syntaxFactory
.Argument(
12518
_syntaxFactory
.NameColon((IdentifierNameSyntax)expression, EatToken()),
12528
list.Add(
_syntaxFactory
.Argument(
12533
return
_syntaxFactory
.TupleExpression(
12884
return
_syntaxFactory
.CollectionExpression(
12907
?
_syntaxFactory
.SpreadElement(this.EatDotDotToken(), this.ParseExpressionCore())
12908
:
_syntaxFactory
.ExpressionElement(this.ParseExpressionCore());
12934
return
_syntaxFactory
.AnonymousObjectCreationExpression(
12943
return
_syntaxFactory
.AnonymousObjectMemberDeclarator(
12989
return
_syntaxFactory
.ArrayCreationExpression(@new, (ArrayTypeSyntax)type, initializer);
13007
argumentList =
_syntaxFactory
.ArgumentList(
13014
?
_syntaxFactory
.ImplicitObjectCreationExpression(@new, argumentList, initializer)
13015
:
_syntaxFactory
.ObjectCreationExpression(@new, type, argumentList, initializer);
13059
return
_syntaxFactory
.WithExpression(
13062
_syntaxFactory
.InitializerExpression(
13087
return
_syntaxFactory
.InitializerExpression(
13158
return
_syntaxFactory
.AssignmentExpression(
13169
return
_syntaxFactory
.AssignmentExpression(
13171
_syntaxFactory
.ImplicitElementAccess(this.ParseBracketedArgumentList()),
13192
return
_syntaxFactory
.InitializerExpression(
13237
return
_syntaxFactory
.ImplicitArrayCreationExpression(
13258
return
_syntaxFactory
.InitializerExpression(
13305
return
_syntaxFactory
.ImplicitStackAllocArrayCreationExpression(
13314
return
_syntaxFactory
.StackAllocArrayCreationExpression(
13362
return
_syntaxFactory
.AnonymousMethodExpression(
13366
_syntaxFactory
.Block(
13374
return
_syntaxFactory
.AnonymousMethodExpression(
13485
return
_syntaxFactory
.ParenthesizedLambdaExpression(
13499
var parameter =
_syntaxFactory
.Parameter(
13502
return
_syntaxFactory
.SimpleLambdaExpression(
13531
return
_syntaxFactory
.ParameterList(
13591
return
_syntaxFactory
.Parameter(
13597
?
_syntaxFactory
.EqualsValueClause(equalsToken, this.ParseExpressionCore())
13757
return
_syntaxFactory
.QueryExpression(fc, body);
13795
_ =>
_syntaxFactory
.SelectClause(
13800
return
_syntaxFactory
.QueryBody(
13833
return
_syntaxFactory
.FromClause(
13844
return
_syntaxFactory
.JoinClause(
13857
?
_syntaxFactory
.JoinIntoClause(ConvertToKeyword(this.EatToken()), this.ParseIdentifierToken())
13864
return
_syntaxFactory
.LetClause(
13874
return
_syntaxFactory
.WhereClause(
13907
return
_syntaxFactory
.OrderByClause(
13939
return
_syntaxFactory
.Ordering(kind, expression, direction);
13945
return
_syntaxFactory
.SelectClause(
13953
return
_syntaxFactory
.GroupClause(
13963
return
_syntaxFactory
.QueryContinuation(
Parser\LanguageParser_Patterns.cs (29)
28
DiscardPatternSyntax dp =>
_syntaxFactory
.IdentifierName(ConvertToIdentifier(dp.UnderscoreToken)),
42
type =
_syntaxFactory
.QualifiedName(leftType, dotToken, simpleName);
63
result =
_syntaxFactory
.BinaryPattern(
109
result =
_syntaxFactory
.BinaryPattern(
162
return
_syntaxFactory
.UnaryPattern(
184
return
_syntaxFactory
.ConstantPattern(this.ParseIdentifierName(ErrorCode.ERR_MissingPattern));
189
return
_syntaxFactory
.DiscardPattern(this.EatContextualToken(SyntaxKind.UnderscoreToken));
197
return
_syntaxFactory
.SlicePattern(
210
return
_syntaxFactory
.RelationalPattern(
236
return
_syntaxFactory
.ConstantPattern(value);
281
return
_syntaxFactory
.VarPattern(varToken, varDesignation);
322
ExpressionSyntax expression =
_syntaxFactory
.ParenthesizedExpression(openParenToken, cp.Expression, closeParenToken);
324
return
_syntaxFactory
.ConstantPattern(expression);
326
return
_syntaxFactory
.ParenthesizedPattern(openParenToken, subpattern, closeParenToken);
331
var positionalPatternClause =
_syntaxFactory
.PositionalPatternClause(openParenToken, subPatterns, closeParenToken);
332
var result =
_syntaxFactory
.RecursivePattern(type, positionalPatternClause, propertyPatternClause0, designation0);
338
return
_syntaxFactory
.RecursivePattern(
347
return
_syntaxFactory
.DeclarationPattern(type, designation);
351
?
_syntaxFactory
.ConstantPattern(ParseExpressionContinued(expression, precedence))
352
:
_syntaxFactory
.TypePattern(type);
449
DiscardPatternSyntax dp =>
_syntaxFactory
.IdentifierName(ConvertToIdentifier(dp.UnderscoreToken)),
467
expr =
_syntaxFactory
.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, newLeft, dotToken, right);
497
return
_syntaxFactory
.PropertyPatternClause(
513
?
_syntaxFactory
.NameColon(identifierName, colon)
514
:
_syntaxFactory
.ExpressionColon(expr, colon);
519
return
_syntaxFactory
.Subpattern(exprColon, pattern);
573
return
_syntaxFactory
.SwitchExpression(
604
var switchExpressionCase =
_syntaxFactory
.SwitchExpressionArm(
648
return
_syntaxFactory
.ListPattern(