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);
3370
return
_syntaxFactory
.ConstructorDeclaration(attributes, modifiers.ToList(), name, paramList, initializer, body, expressionBody, semicolon);
3402
:
_syntaxFactory
.ArgumentList(
3407
return
_syntaxFactory
.ConstructorInitializer(kind, colon, token, argumentList);
3416
var parameterList =
_syntaxFactory
.ParameterList(
3424
return
_syntaxFactory
.DestructorDeclaration(attributes, modifiers.ToList(), tilde, name, parameterList, body, expressionBody, semicolon);
3565
return
_syntaxFactory
.MethodDeclaration(
3706
return
_syntaxFactory
.ConversionOperatorDeclaration(
3714
_syntaxFactory
.ParameterList(
3745
return
_syntaxFactory
.ConversionOperatorDeclaration(
3825
return
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
4028
return
_syntaxFactory
.OperatorDeclaration(
4090
return
_syntaxFactory
.IndexerDeclaration(
4146
initializer =
_syntaxFactory
.EqualsValueClause(equals, value: value);
4159
return
_syntaxFactory
.PropertyDeclaration(
4227
return
_syntaxFactory
.AccessorList(
4235
return
_syntaxFactory
.ArrowExpressionClause(
4248
return refKeyword == null ? expression :
_syntaxFactory
.RefExpression(refKeyword, expression);
4559
return
_syntaxFactory
.AccessorDeclaration(
4596
return
_syntaxFactory
.ParameterList(open, parameters, close);
4607
return
_syntaxFactory
.BracketedParameterList(open, parameters, close);
4791
return
_syntaxFactory
.Parameter(
4820
return
_syntaxFactory
.Parameter(
4825
equalsToken == null ? null :
_syntaxFactory
.EqualsValueClause(equalsToken, this.ParseExpressionCore()));
4894
return
_syntaxFactory
.FieldDeclaration(
4896
_syntaxFactory
.VariableDeclaration(
4933
return
_syntaxFactory
.EventDeclaration(
4942
_syntaxFactory
.AccessorList(
4991
var decl =
_syntaxFactory
.EventDeclaration(
5030
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
5034
return
_syntaxFactory
.FieldDeclaration(
5037
_syntaxFactory
.VariableDeclaration(type, variables),
5068
return
_syntaxFactory
.EventFieldDeclaration(
5072
_syntaxFactory
.VariableDeclaration(type, variables),
5384
return
_syntaxFactory
.VariableDeclarator(missingIdentifier, null, null);
5433
initializer =
_syntaxFactory
.EqualsValueClause(
5435
refKeyword == null ? init :
_syntaxFactory
.RefExpression(refKeyword, init));
5492
args.Add(
_syntaxFactory
.Argument(null, refKindKeyword: null, expression));
5500
argumentList =
_syntaxFactory
.BracketedArgumentList(open, _pool.ToListAndFree(args), close);
5535
return
_syntaxFactory
.VariableDeclarator(name, argumentList, initializer);
5587
return
_syntaxFactory
.FieldDeclaration(
5590
_syntaxFactory
.VariableDeclaration(
5617
return
_syntaxFactory
.DelegateDeclaration(
5651
tmpList.Add(
_syntaxFactory
.SimpleBaseType(type));
5652
baseList =
_syntaxFactory
.BaseList(
5692
return
_syntaxFactory
.EnumDeclaration(
5726
equalsValue =
_syntaxFactory
.EqualsValueClause(
5733
return
_syntaxFactory
.EnumMemberDeclaration(memberAttrs, modifiers: default, memberName, equalsValue);
5754
return
_syntaxFactory
.IdentifierName(CreateMissingIdentifierToken());
5901
return
_syntaxFactory
.TypeParameterList(
5936
return
_syntaxFactory
.TypeParameter(
5951
return
_syntaxFactory
.TypeParameter(
5984
name =
_syntaxFactory
.GenericName(
5986
_syntaxFactory
.TypeArgumentList(
6331
var omittedTypeArgumentInstance =
_syntaxFactory
.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken));
6647
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(
6662
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
6800
explicitInterfaceOpt =
_syntaxFactory
.ExplicitInterfaceSpecifier(explicitInterfaceName, separator);
6842
return
_syntaxFactory
.QualifiedName(left, separator, right);
6857
return
_syntaxFactory
.QualifiedName(left, separator, right);
6863
identifierLeft =
_syntaxFactory
.IdentifierName(ConvertToKeyword(identifierLeft.Identifier));
6868
return WithAdditionalDiagnostics(
_syntaxFactory
.AliasQualifiedName(identifierLeft, separator, right), left.GetDiagnostics());
7327
return
_syntaxFactory
.PredefinedType(this.EatToken());
7351
return
_syntaxFactory
.RefType(
7404
type =
_syntaxFactory
.NullableType(type, question);
7447
type =
_syntaxFactory
.ArrayType(type, _pool.ToListAndFree(ranks));
7648
var omittedArraySizeExpressionInstance =
_syntaxFactory
.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken));
7699
return
_syntaxFactory
.ArrayRankSpecifier(
7725
list.Add(
_syntaxFactory
.TupleElement(this.CreateMissingIdentifierName(), identifier: null));
7730
list.Add(
_syntaxFactory
.TupleElement(missing, identifier: null));
7733
return
_syntaxFactory
.TupleType(
7741
return
_syntaxFactory
.TupleElement(
7765
return
_syntaxFactory
.PredefinedType(token);
7963
type =
_syntaxFactory
.PointerType(type, this.EatToken());
8132
return
_syntaxFactory
.EmptyStatement(attributes, this.EatToken());
8801
var block =
_syntaxFactory
.Block(
8832
return
_syntaxFactory
.Block(
8994
return
_syntaxFactory
.FixedStatement(
9052
return
_syntaxFactory
.BreakStatement(
9060
return
_syntaxFactory
.ContinueStatement(
9106
finallyClause =
_syntaxFactory
.FinallyClause(
9117
finallyClause =
_syntaxFactory
.FinallyClause(
9122
return
_syntaxFactory
.TryStatement(
9130
=>
_syntaxFactory
.Block(
9166
decl =
_syntaxFactory
.CatchDeclaration(openParen, type, name, closeParen);
9191
filter =
_syntaxFactory
.CatchFilterClause(whenKeyword, openParen, filterExpression, closeParen);
9198
return
_syntaxFactory
.CatchClause(@catch, decl, filter, block);
9235
return
_syntaxFactory
.CheckedStatement(
9255
return
_syntaxFactory
.DoStatement(
9329
var forStatement =
_syntaxFactory
.ForStatement(
9506
return
_syntaxFactory
.ForEachStatement(attributes, awaitTokenOpt, @foreach, openParen, decl.Type, identifier, @in, expression, closeParen, statement);
9510
return
_syntaxFactory
.ForEachVariableStatement(attributes, awaitTokenOpt, @foreach, openParen, variable, @in, expression, closeParen, statement);
9694
return
_syntaxFactory
.GotoStatement(
9743
_syntaxFactory
.ElseClause(
9746
ifStatement =
_syntaxFactory
.IfStatement(
9767
return
_syntaxFactory
.IfStatement(
9781
:
_syntaxFactory
.ElseClause(
9789
return
_syntaxFactory
.LockStatement(
9801
return
_syntaxFactory
.ReturnStatement(
9836
return
_syntaxFactory
.YieldStatement(
9855
return
_syntaxFactory
.SwitchStatement(
9938
label =
_syntaxFactory
.CaseSwitchLabel(
9949
node =
_syntaxFactory
.ConstantPattern(ex);
9956
label =
_syntaxFactory
.CasePatternSwitchLabel(
9964
label =
_syntaxFactory
.CaseSwitchLabel(
9974
label =
_syntaxFactory
.DefaultSwitchLabel(
9988
return
_syntaxFactory
.SwitchSection(
9996
return
_syntaxFactory
.ThrowStatement(
10006
return
_syntaxFactory
.UnsafeStatement(
10024
return
_syntaxFactory
.UsingStatement(
10142
return
_syntaxFactory
.WhileStatement(
10157
return
_syntaxFactory
.LabeledStatement(
10236
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
10253
return
_syntaxFactory
.LocalDeclarationStatement(
10258
_syntaxFactory
.VariableDeclaration(type, variables.ToList()),
10363
result =
_syntaxFactory
.ParenthesizedVariableDesignation(
10383
?
_syntaxFactory
.DiscardDesignation(this.EatContextualToken(SyntaxKind.UnderscoreToken))
10384
:
_syntaxFactory
.SingleVariableDesignation(this.EatToken(SyntaxKind.IdentifierToken));
10394
return
_syntaxFactory
.WhenClause(
10422
return
_syntaxFactory
.VariableDeclaration(
10441
type =
_syntaxFactory
.ScopedType(scopedKeyword, type);
10710
return
_syntaxFactory
.LocalFunctionStatement(
10742
return
_syntaxFactory
.ExpressionStatement(attributes, expression, semicolon);
11153
return
_syntaxFactory
.PrefixUnaryExpression(
11164
return
_syntaxFactory
.RangeExpression(
11174
return
_syntaxFactory
.AwaitExpression(
11288
return
_syntaxFactory
.BinaryExpression(
11303
return
_syntaxFactory
.RangeExpression(
11315
return
_syntaxFactory
.BinaryExpression(operatorExpressionKind, leftOperand, operatorToken, this.ParseSubExpression(newPrecedence));
11367
var conditionalExpression =
_syntaxFactory
.ConditionalExpression(
11372
_syntaxFactory
.IdentifierName(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)));
11377
return
_syntaxFactory
.ConditionalExpression(
11526
rhs =
_syntaxFactory
.RefExpression(
11535
return
_syntaxFactory
.AssignmentExpression(
11600
return
_syntaxFactory
.DeclarationExpression(
11601
scopedKeyword == null ? type :
_syntaxFactory
.ScopedType(scopedKeyword, type),
11607
return
_syntaxFactory
.ThrowExpression(
11617
PatternSyntax pattern =>
_syntaxFactory
.IsPatternExpression(leftOperand, opToken, pattern),
11618
TypeSyntax type =>
_syntaxFactory
.BinaryExpression(SyntaxKind.IsExpression, leftOperand, opToken, type),
11690
return
_syntaxFactory
.FieldExpression(this.EatContextualToken(SyntaxKind.FieldKeyword));
11707
return
_syntaxFactory
.ThisExpression(this.EatToken());
11723
return
_syntaxFactory
.LiteralExpression(SyntaxFacts.GetLiteralExpression(tk), this.EatToken());
11754
return this.AddError(
_syntaxFactory
.RefExpression(refKeyword, this.ParseExpressionCore()), ErrorCode.ERR_InvalidExprTerm, SyntaxFacts.GetText(tk));
11764
var expr =
_syntaxFactory
.PredefinedType(this.EatToken());
11804
expr =
_syntaxFactory
.InvocationExpression(expr, this.ParseParenthesizedArgumentList());
11808
expr =
_syntaxFactory
.ElementAccessExpression(expr, this.ParseBracketedArgumentList());
11813
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxFacts.GetPostfixUnaryExpression(this.CurrentToken.Kind), expr, this.EatToken());
11819
expr =
_syntaxFactory
.MemberAccessExpression(
11835
expr =
_syntaxFactory
.MemberAccessExpression(SyntaxKind.PointerMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression));
11852
return
_syntaxFactory
.MemberAccessExpression(
11857
expr =
_syntaxFactory
.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression));
11870
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, this.EatToken());
11883
return
_syntaxFactory
.BaseExpression(this.EatToken());
11998
conditionalAccessExpression =
_syntaxFactory
.ConditionalAccessExpression(
12013
return (questionToken: EatToken(),
_syntaxFactory
.MemberBindingExpression(this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)));
12016
return (questionToken: EatToken(),
_syntaxFactory
.ElementBindingExpression(this.ParseBracketedArgumentList()));
12057
expr =
_syntaxFactory
.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, EatToken());
12095
=>
_syntaxFactory
.InvocationExpression(expr, this.ParseParenthesizedArgumentList()),
12097
=>
_syntaxFactory
.ElementAccessExpression(expr, this.ParseBracketedArgumentList()),
12099
=>
_syntaxFactory
.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)),
12119
return
_syntaxFactory
.ArgumentList(openToken, arguments, closeToken);
12135
return
_syntaxFactory
.BracketedArgumentList(openToken, arguments, closeToken);
12247
?
_syntaxFactory
.NameColon(
12284
return
_syntaxFactory
.Argument(nameColon, refKindKeyword, expression);
12289
return
_syntaxFactory
.TypeOfExpression(
12301
return
_syntaxFactory
.DefaultExpression(
12309
return
_syntaxFactory
.LiteralExpression(SyntaxKind.DefaultLiteralExpression, keyword);
12315
return
_syntaxFactory
.SizeOfExpression(
12324
return
_syntaxFactory
.MakeRefExpression(
12333
return
_syntaxFactory
.RefTypeExpression(
12346
return
_syntaxFactory
.CheckedExpression(
12356
return
_syntaxFactory
.RefValueExpression(
12498
return
_syntaxFactory
.CastExpression(
12516
_syntaxFactory
.Argument(nameColon: null, refKindKeyword: null, expression));
12524
_syntaxFactory
.Argument(
12525
_syntaxFactory
.NameColon((IdentifierNameSyntax)expression, EatToken()),
12530
return
_syntaxFactory
.ParenthesizedExpression(
12547
?
_syntaxFactory
.Argument(nameColon: null, refKindKeyword: null, expression: expression)
12548
:
_syntaxFactory
.Argument(
12549
_syntaxFactory
.NameColon((IdentifierNameSyntax)expression, EatToken()),
12559
list.Add(
_syntaxFactory
.Argument(
12564
return
_syntaxFactory
.TupleExpression(
12915
return
_syntaxFactory
.CollectionExpression(
12938
?
_syntaxFactory
.SpreadElement(this.EatDotDotToken(), this.ParseExpressionCore())
12939
:
_syntaxFactory
.ExpressionElement(this.ParseExpressionCore());
12965
return
_syntaxFactory
.AnonymousObjectCreationExpression(
12974
return
_syntaxFactory
.AnonymousObjectMemberDeclarator(
13020
return
_syntaxFactory
.ArrayCreationExpression(@new, (ArrayTypeSyntax)type, initializer);
13038
argumentList =
_syntaxFactory
.ArgumentList(
13045
?
_syntaxFactory
.ImplicitObjectCreationExpression(@new, argumentList, initializer)
13046
:
_syntaxFactory
.ObjectCreationExpression(@new, type, argumentList, initializer);
13090
return
_syntaxFactory
.WithExpression(
13093
_syntaxFactory
.InitializerExpression(
13118
return
_syntaxFactory
.InitializerExpression(
13189
return
_syntaxFactory
.AssignmentExpression(
13200
return
_syntaxFactory
.AssignmentExpression(
13202
_syntaxFactory
.ImplicitElementAccess(this.ParseBracketedArgumentList()),
13223
return
_syntaxFactory
.InitializerExpression(
13268
return
_syntaxFactory
.ImplicitArrayCreationExpression(
13289
return
_syntaxFactory
.InitializerExpression(
13336
return
_syntaxFactory
.ImplicitStackAllocArrayCreationExpression(
13345
return
_syntaxFactory
.StackAllocArrayCreationExpression(
13393
return
_syntaxFactory
.AnonymousMethodExpression(
13397
_syntaxFactory
.Block(
13405
return
_syntaxFactory
.AnonymousMethodExpression(
13516
return
_syntaxFactory
.ParenthesizedLambdaExpression(
13530
var parameter =
_syntaxFactory
.Parameter(
13533
return
_syntaxFactory
.SimpleLambdaExpression(
13562
return
_syntaxFactory
.ParameterList(
13622
return
_syntaxFactory
.Parameter(
13628
?
_syntaxFactory
.EqualsValueClause(equalsToken, this.ParseExpressionCore())
13788
return
_syntaxFactory
.QueryExpression(fc, body);
13826
_ =>
_syntaxFactory
.SelectClause(
13831
return
_syntaxFactory
.QueryBody(
13864
return
_syntaxFactory
.FromClause(
13875
return
_syntaxFactory
.JoinClause(
13888
?
_syntaxFactory
.JoinIntoClause(ConvertToKeyword(this.EatToken()), this.ParseIdentifierToken())
13895
return
_syntaxFactory
.LetClause(
13905
return
_syntaxFactory
.WhereClause(
13938
return
_syntaxFactory
.OrderByClause(
13970
return
_syntaxFactory
.Ordering(kind, expression, direction);
13976
return
_syntaxFactory
.SelectClause(
13984
return
_syntaxFactory
.GroupClause(
13994
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(