130(LanguageNames.CSharp, typeof(Microsoft.CodeAnalysis.CSharp.SyntaxKind)),

69assignment.Parent?.Kind() is SyntaxKind.ObjectInitializerExpression or SyntaxKind.WithInitializerExpression) 77!(id.Parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression && 135case GotoStatementSyntax { RawKind: (int)SyntaxKind.GotoStatement }: 157!(expression.Parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression && 223case MemberAccessExpressionSyntax { RawKind: (int)SyntaxKind.SimpleMemberAccessExpression } memberAccess when memberAccess.Expression == id: 360case SyntaxKind.SelectClause: 371case SyntaxKind.GroupClause: 403case SyntaxKind.WhereClause: 405case SyntaxKind.JoinClause: 407case SyntaxKind.OrderByClause: 409case SyntaxKind.FromClause: 411case SyntaxKind.LetClause:

396Debug.Assert(expr.Syntax.Kind() != SyntaxKind.Argument || valueKind == BindValueKind.RefOrOut);

70if (nameToken.Kind() == SyntaxKind.IdentifierToken) 91fieldSyntaxNodes[i] = (nameToken.Kind() == SyntaxKind.IdentifierToken) ? (CSharpSyntaxNode)nameToken.Parent! : fieldInitializer; 157case SyntaxKind.QualifiedName: 160case SyntaxKind.ConditionalAccessExpression: 162if (expr.Kind() == SyntaxKind.MemberBindingExpression) 168case SyntaxKind.IdentifierName: 169case SyntaxKind.SimpleMemberAccessExpression: 224expressionType = CreateErrorType(SyntaxFacts.GetText(SyntaxKind.VoidKeyword));

279Debug.Assert(boundAttribute.Syntax.Kind() == SyntaxKind.Attribute);

133case SyntaxKind.ClassConstraint: 151if (questionToken.IsKind(SyntaxKind.QuestionToken)) 174case SyntaxKind.StructConstraint: 192case SyntaxKind.ConstructorConstraint: 215case SyntaxKind.DefaultConstraint: 238case SyntaxKind.TypeConstraint:

830if (!lambdaSymbol.SyntaxNode.IsKind(SyntaxKind.AnonymousMethodExpression)) 1164else if (node.Kind() == SyntaxKind.AwaitExpression && memberSymbol.Name == WellKnownMemberNames.GetAwaiter) 1186if (node.Parent != null && node.Parent.Kind() == SyntaxKind.InvocationExpression)

30case SyntaxKind.TypeCref: 32case SyntaxKind.QualifiedCref: 34case SyntaxKind.NameMemberCref: 35case SyntaxKind.IndexerMemberCref: 36case SyntaxKind.OperatorMemberCref: 37case SyntaxKind.ConversionOperatorMemberCref: 116case SyntaxKind.NameMemberCref: 119case SyntaxKind.IndexerMemberCref: 122case SyntaxKind.OperatorMemberCref: 125case SyntaxKind.ConversionOperatorMemberCref: 226bool isChecked = syntax.CheckedKeyword.IsKind(SyntaxKind.CheckedKeyword); 231SyntaxKind operatorTokenKind = syntax.OperatorToken.Kind(); 267bool isChecked = syntax.CheckedKeyword.IsKind(SyntaxKind.CheckedKeyword); 271if (syntax.ImplicitOrExplicitKeyword.Kind() == SyntaxKind.ImplicitKeyword) 977if (typeSyntax.Parent.Kind() == SyntaxKind.ConversionOperatorMemberCref) 1022return parentSyntax == null || parentSyntax.IsKind(SyntaxKind.XmlCrefAttribute)

42case SyntaxKind.ExpressionStatement: 49case SyntaxKind.ForStatement: 179if (parent is null || parent.Kind() == SyntaxKind.ForEachVariableStatement) 184Debug.Assert(parent.Kind() == SyntaxKind.SimpleAssignmentExpression); 194case SyntaxKind.ExpressionStatement: 197case SyntaxKind.ForStatement: 303var elementSyntax = syntax.Kind() == SyntaxKind.TupleExpression ? ((TupleExpressionSyntax)syntax).Arguments[i] : syntax; 740case SyntaxKind.DeclarationExpression: 753if (component.Designation.Kind() == SyntaxKind.ParenthesizedVariableDesignation) 771case SyntaxKind.TupleExpression: 809case SyntaxKind.SingleVariableDesignation: 814case SyntaxKind.DiscardDesignation: 836case SyntaxKind.ParenthesizedVariableDesignation:

563case SyntaxKind.AnonymousMethodExpression: 564case SyntaxKind.ParenthesizedLambdaExpression: 565case SyntaxKind.SimpleLambdaExpression: 567case SyntaxKind.ThisExpression: 569case SyntaxKind.BaseExpression: 571case SyntaxKind.InvocationExpression: 573case SyntaxKind.ArrayInitializerExpression: 575case SyntaxKind.ArrayCreationExpression: 577case SyntaxKind.ImplicitArrayCreationExpression: 579case SyntaxKind.StackAllocArrayCreationExpression: 581case SyntaxKind.ImplicitStackAllocArrayCreationExpression: 583case SyntaxKind.ObjectCreationExpression: 585case SyntaxKind.ImplicitObjectCreationExpression: 587case SyntaxKind.IdentifierName: 588case SyntaxKind.GenericName: 590case SyntaxKind.SimpleMemberAccessExpression: 591case SyntaxKind.PointerMemberAccessExpression: 593case SyntaxKind.SimpleAssignmentExpression: 595case SyntaxKind.CastExpression: 597case SyntaxKind.ElementAccessExpression: 599case SyntaxKind.AddExpression: 600case SyntaxKind.MultiplyExpression: 601case SyntaxKind.SubtractExpression: 602case SyntaxKind.DivideExpression: 603case SyntaxKind.ModuloExpression: 604case SyntaxKind.EqualsExpression: 605case SyntaxKind.NotEqualsExpression: 606case SyntaxKind.GreaterThanExpression: 607case SyntaxKind.LessThanExpression: 608case SyntaxKind.GreaterThanOrEqualExpression: 609case SyntaxKind.LessThanOrEqualExpression: 610case SyntaxKind.BitwiseAndExpression: 611case SyntaxKind.BitwiseOrExpression: 612case SyntaxKind.ExclusiveOrExpression: 613case SyntaxKind.LeftShiftExpression: 614case SyntaxKind.RightShiftExpression: 615case SyntaxKind.UnsignedRightShiftExpression: 618case SyntaxKind.LogicalAndExpression: 619case SyntaxKind.LogicalOrExpression: 621case SyntaxKind.CoalesceExpression: 623case SyntaxKind.ConditionalAccessExpression: 626case SyntaxKind.MemberBindingExpression: 629case SyntaxKind.ElementBindingExpression: 632case SyntaxKind.IsExpression: 635case SyntaxKind.AsExpression: 638case SyntaxKind.UnaryPlusExpression: 639case SyntaxKind.UnaryMinusExpression: 640case SyntaxKind.LogicalNotExpression: 641case SyntaxKind.BitwiseNotExpression: 644case SyntaxKind.IndexExpression: 647case SyntaxKind.RangeExpression: 650case SyntaxKind.AddressOfExpression: 653case SyntaxKind.PointerIndirectionExpression: 656case SyntaxKind.PostIncrementExpression: 657case SyntaxKind.PostDecrementExpression: 660case SyntaxKind.PreIncrementExpression: 661case SyntaxKind.PreDecrementExpression: 664case SyntaxKind.ConditionalExpression: 667case SyntaxKind.SwitchExpression: 670case SyntaxKind.NumericLiteralExpression: 671case SyntaxKind.StringLiteralExpression: 672case SyntaxKind.CharacterLiteralExpression: 673case SyntaxKind.TrueLiteralExpression: 674case SyntaxKind.FalseLiteralExpression: 675case SyntaxKind.NullLiteralExpression: 678case SyntaxKind.Utf8StringLiteralExpression: 681case SyntaxKind.DefaultLiteralExpression: 685case SyntaxKind.ParenthesizedExpression: 690case SyntaxKind.UncheckedExpression: 691case SyntaxKind.CheckedExpression: 694case SyntaxKind.DefaultExpression: 697case SyntaxKind.TypeOfExpression: 700case SyntaxKind.SizeOfExpression: 703case SyntaxKind.AddAssignmentExpression: 704case SyntaxKind.AndAssignmentExpression: 705case SyntaxKind.DivideAssignmentExpression: 706case SyntaxKind.ExclusiveOrAssignmentExpression: 707case SyntaxKind.LeftShiftAssignmentExpression: 708case SyntaxKind.ModuloAssignmentExpression: 709case SyntaxKind.MultiplyAssignmentExpression: 710case SyntaxKind.OrAssignmentExpression: 711case SyntaxKind.RightShiftAssignmentExpression: 712case SyntaxKind.UnsignedRightShiftAssignmentExpression: 713case SyntaxKind.SubtractAssignmentExpression: 716case SyntaxKind.CoalesceAssignmentExpression: 719case SyntaxKind.AliasQualifiedName: 720case SyntaxKind.PredefinedType: 723case SyntaxKind.QueryExpression: 726case SyntaxKind.AnonymousObjectCreationExpression: 729case SyntaxKind.QualifiedName: 732case SyntaxKind.ComplexElementInitializerExpression: 735case SyntaxKind.ArgListExpression: 738case SyntaxKind.RefTypeExpression: 741case SyntaxKind.MakeRefExpression: 744case SyntaxKind.RefValueExpression: 747case SyntaxKind.AwaitExpression: 750case SyntaxKind.OmittedArraySizeExpression: 751case SyntaxKind.OmittedTypeArgument: 752case SyntaxKind.ObjectInitializerExpression: 757case SyntaxKind.NullableType: 766case SyntaxKind.InterpolatedStringExpression: 769case SyntaxKind.IsPatternExpression: 772case SyntaxKind.TupleExpression: 775case SyntaxKind.ThrowExpression: 778case SyntaxKind.RefType: 781case SyntaxKind.ScopedType: 784case SyntaxKind.RefExpression: 787case SyntaxKind.DeclarationExpression: 790case SyntaxKind.SuppressNullableWarningExpression: 793case SyntaxKind.WithExpression: 861case SyntaxKind.ConditionalExpression: // ?: 866case SyntaxKind.CoalesceExpression: // ?? 871case SyntaxKind.SwitchExpressionArm: 872case SyntaxKind.ArrowExpressionClause: 873case SyntaxKind.ParenthesizedLambdaExpression: 874case SyntaxKind.SimpleLambdaExpression: 908case SyntaxKind.SingleVariableDesignation: 914case SyntaxKind.DiscardDesignation: 918case SyntaxKind.ParenthesizedVariableDesignation: 1495SeparatedSyntaxList<TypeSyntax> typeArgumentList = node.Kind() == SyntaxKind.GenericName 1548if (!isNamedType && (hasTypeArguments || node.Kind() == SyntaxKind.GenericName)) 1680return (parent?.Kind() == SyntaxKind.Argument && 1681((ArgumentSyntax)parent).RefOrOutKeyword.Kind() == SyntaxKind.OutKeyword); 2167if (node.Kind() == SyntaxKind.PredefinedType) 2310else if (this.ContainingType is null || node.Parent is null || (node.Parent.Kind() != SyntaxKind.SimpleMemberAccessExpression && node.Parent.Kind() != SyntaxKind.ElementAccessExpression)) 2344Debug.Assert(node.OperatorToken.IsKind(SyntaxKind.CaretToken)); 2732case SyntaxKind.PredefinedType: 2735case SyntaxKind.SimpleLambdaExpression: 2738case SyntaxKind.ParenthesizedExpression: 2741case SyntaxKind.CastExpression: 2744case SyntaxKind.SimpleMemberAccessExpression: 2745case SyntaxKind.PointerMemberAccessExpression: 2747case SyntaxKind.MemberBindingExpression: 2805case SyntaxKind.ParenthesizedLambdaExpression: 2806case SyntaxKind.SimpleLambdaExpression: 2807case SyntaxKind.AnonymousMethodExpression: 2808case SyntaxKind.InvocationExpression: 2809case SyntaxKind.ObjectCreationExpression: 2810case SyntaxKind.ImplicitObjectCreationExpression: 2811case SyntaxKind.ParenthesizedExpression: // this is never allowed in legacy compiler 2812case SyntaxKind.DeclarationExpression: 2862if (argumentSyntax.RefOrOutKeyword.Kind() != SyntaxKind.None) 2870if (argumentSyntax.RefKindKeyword.IsKind(SyntaxKind.InKeyword)) 2873if (argumentSyntax.Expression.Kind() == SyntaxKind.DeclarationExpression) 2875if (argumentSyntax.RefKindKeyword.IsKind(SyntaxKind.OutKeyword)) 2895case SyntaxKind.DiscardDesignation: 2918case SyntaxKind.SingleVariableDesignation: 3360if (arg.Kind() != SyntaxKind.OmittedArraySizeExpression) 3381if (dimension.Kind() != SyntaxKind.OmittedArraySizeExpression) 3508if (expression.Kind() == SyntaxKind.ArrayInitializerExpression) 3587if (expr.Kind() == SyntaxKind.ArrayInitializerExpression) 3711creationSyntax.Kind() == SyntaxKind.ArrayCreationExpression || 3712creationSyntax.Kind() == SyntaxKind.ImplicitArrayCreationExpression); 3715Debug.Assert(boundInitExprOpt.IsDefault || creationSyntax.Kind() == SyntaxKind.ImplicitArrayCreationExpression); 3745var isInferred = creationSyntax.IsKind(SyntaxKind.ImplicitArrayCreationExpression); 3780initSyntax.Parent.Kind() != SyntaxKind.EqualsValueClause || 3790if (typeSyntax.Kind() != SyntaxKind.ArrayType) 3826if (size.Kind() != SyntaxKind.OmittedArraySizeExpression) 3843if (countSyntax.Kind() != SyntaxKind.OmittedArraySizeExpression) 3901typeSyntax: node.Kind() == SyntaxKind.StackAllocArrayCreationExpression 3922if (!equalsValueClause.IsKind(SyntaxKind.EqualsValueClause)) 3929if (!variableDeclarator.IsKind(SyntaxKind.VariableDeclarator)) 3935if (!variableDeclaration.IsKind(SyntaxKind.VariableDeclaration)) 3941variableDeclaration.Parent.IsKind(SyntaxKind.LocalDeclarationStatement) || 3942variableDeclaration.Parent.IsKind(SyntaxKind.ForStatement); 3957Debug.Assert(node.IsKind(SyntaxKind.ImplicitStackAllocArrayCreationExpression) || node.IsKind(SyntaxKind.StackAllocArrayCreationExpression)); 3994bool isInferred = node.IsKind(SyntaxKind.ImplicitStackAllocArrayCreationExpression); 4144initializerArgumentListOpt.Parent.Kind() != SyntaxKind.ThisConstructorInitializer; 4187Debug.Assert(initializerArgumentListOpt.Parent.Kind() == SyntaxKind.ThisConstructorInitializer); 4254(initializerArgumentListOpt != null && initializerArgumentListOpt.Parent.Kind() == SyntaxKind.ThisConstructorInitializer)); 4675else if (node.Type.Kind() == SyntaxKind.TupleType) 4771case SyntaxKind.ObjectInitializerExpression: 4776case SyntaxKind.WithInitializerExpression: 4780case SyntaxKind.CollectionInitializerExpression: 4800case SyntaxKind.ObjectInitializerExpression: 4801case SyntaxKind.CollectionInitializerExpression: 4802Debug.Assert(syntax.Parent.Parent.Kind() != SyntaxKind.WithInitializerExpression); 4823Debug.Assert(initializerSyntax.Kind() == SyntaxKind.ObjectInitializerExpression || 4824initializerSyntax.Kind() == SyntaxKind.WithInitializerExpression); 4827if (initializerSyntax.Kind() == SyntaxKind.ObjectInitializerExpression) 4869if (memberInitializer.Kind() == SyntaxKind.SimpleAssignmentExpression) 4921SyntaxKind rhsKind = namedAssignment.Right.Kind(); 4922bool isRef = rhsKind is SyntaxKind.RefExpression; 4923bool isRhsNestedInitializer = rhsKind is SyntaxKind.ObjectInitializerExpression or SyntaxKind.CollectionInitializerExpression; 4926if (leftSyntax.Kind() == SyntaxKind.IdentifierName) 4970else if (leftSyntax.Kind() == SyntaxKind.ImplicitElementAccess) 5193Debug.Assert(memberInitializerSyntax.Kind() == SyntaxKind.SimpleAssignmentExpression); 5321Debug.Assert(initializerSyntax.Kind() == SyntaxKind.CollectionInitializerExpression); 5403if (elementInitializer.Kind() == SyntaxKind.ComplexElementInitializerExpression) 5469Debug.Assert(node.Kind() == SyntaxKind.ComplexElementInitializerExpression); 6222if (node.Kind() is SyntaxKind.NumericLiteralExpression) 6265if (node.Token.Kind() is SyntaxKind.SingleLineRawStringLiteralToken or SyntaxKind.MultiLineRawStringLiteralToken) 6275Debug.Assert(node.Kind() == SyntaxKind.Utf8StringLiteralExpression); 6276Debug.Assert(node.Token.Kind() is SyntaxKind.Utf8StringLiteralToken or SyntaxKind.Utf8SingleLineRawStringLiteralToken or SyntaxKind.Utf8MultiLineRawStringLiteralToken); 6278if (node.Token.Kind() is SyntaxKind.Utf8SingleLineRawStringLiteralToken or SyntaxKind.Utf8MultiLineRawStringLiteralToken) 6312if (node.Kind() == SyntaxKind.SimpleMemberAccessExpression) 6319Debug.Assert(node.Kind() == SyntaxKind.PointerMemberAccessExpression); 6368Debug.Assert((left.Parent is MemberAccessExpressionSyntax { RawKind: (int)SyntaxKind.SimpleMemberAccessExpression } memberAccess && memberAccess.Expression == left) || 6471SeparatedSyntaxList<TypeSyntax> typeArgumentsSyntax = right.Kind() == SyntaxKind.GenericName ? 6594var typeArgumentsSyntax = right.Kind() == SyntaxKind.GenericName ? ((GenericNameSyntax)right).TypeArgumentList.Arguments : default(SeparatedSyntaxList<TypeSyntax>); 6918if (!boundMethodGroup.HasErrors && typeArgumentsSyntax.Any(SyntaxKind.OmittedTypeArgument)) 6994node.Kind() == SyntaxKind.AwaitExpression && plainName == WellKnownMemberNames.GetResult) 8445var name = candidate.IsIndexer ? SyntaxFacts.GetText(SyntaxKind.ThisKeyword) : candidate.Name; 9383case SyntaxKind.ExpressionStatement: 9387case SyntaxKind.SimpleLambdaExpression: 9391case SyntaxKind.ParenthesizedLambdaExpression: 9395case SyntaxKind.ArrowExpressionClause: 9399case SyntaxKind.ForStatement: 9464while (receiver.IsKind(SyntaxKind.ParenthesizedExpression))

96return (this.Flags.Includes(BinderFlags.UnsafeRegion) || !modifiers.Any(SyntaxKind.UnsafeKeyword))

25if (node.StringStartToken.Kind() is SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken) 51var isNonVerbatimInterpolatedString = node.StringStartToken.Kind() != SyntaxKind.InterpolatedVerbatimStringStartToken; 52var isRawInterpolatedString = node.StringStartToken.Kind() is SyntaxKind.InterpolatedSingleLineRawStringStartToken or SyntaxKind.InterpolatedMultiLineRawStringStartToken; 60case SyntaxKind.Interpolation: 154case SyntaxKind.InterpolatedStringText:

28case SyntaxKind.IdentifierName: 29case SyntaxKind.GenericName: 31case SyntaxKind.SimpleMemberAccessExpression: 32case SyntaxKind.PointerMemberAccessExpression: 34case SyntaxKind.ParenthesizedExpression: 170bool isArglist = node.Expression.Kind() == SyntaxKind.ArgListExpression; 1134WarnOnAccessOfOffDefault(node.Kind() == SyntaxKind.InvocationExpression ? 1499case SyntaxKind.QualifiedName: 1502case SyntaxKind.SimpleMemberAccessExpression: 1503case SyntaxKind.PointerMemberAccessExpression: 1934case SyntaxKind.IdentifierName: 1940case SyntaxKind.GenericName: 1946case SyntaxKind.SimpleMemberAccessExpression: 1952case SyntaxKind.BaseExpression: 1953case SyntaxKind.ThisExpression: 1962case SyntaxKind.AliasQualifiedName: 1974case SyntaxKind.ThisExpression: 1975case SyntaxKind.BaseExpression: 1976case SyntaxKind.PredefinedType: 1998this.LookupSymbolsWithFallback(lookupResult, SyntaxFacts.GetText(SyntaxKind.NameOfKeyword), useSiteInfo: ref discardedUseSiteInfo, arity: 0, options: options);

67case SyntaxKind.SimpleLambdaExpression: 73case SyntaxKind.ParenthesizedLambdaExpression: 85case SyntaxKind.AnonymousMethodExpression: 106if (modifier.IsKind(SyntaxKind.AsyncKeyword)) 111else if (modifier.IsKind(SyntaxKind.StaticKeyword)) 149var isAnonymousMethod = syntax.IsKind(SyntaxKind.AnonymousMethodExpression); 186if (isLastParameter && paramsKeyword.Kind() != SyntaxKind.None) 201attributesBuilder.Add(syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression ? p.AttributeLists : default); 269if (syntax.Kind() == SyntaxKind.ParenthesizedLambdaExpression) 275Error(diagnostics, syntax.Kind() == SyntaxKind.SimpleLambdaExpression ? ErrorCode.ERR_AttributesRequireParenthesizedLambdaExpression : ErrorCode.ERR_AttributesNotAllowed, attributeList); 288if (syntax is IdentifierNameSyntax { Identifier.RawContextualKind: (int)SyntaxKind.VarKeyword }) 369var isParams = paramsKeyword.Kind() != SyntaxKind.None;

423protected static bool IsSimpleBinaryOperator(SyntaxKind kind) 428case SyntaxKind.AddExpression: 429case SyntaxKind.MultiplyExpression: 430case SyntaxKind.SubtractExpression: 431case SyntaxKind.DivideExpression: 432case SyntaxKind.ModuloExpression: 433case SyntaxKind.EqualsExpression: 434case SyntaxKind.NotEqualsExpression: 435case SyntaxKind.GreaterThanExpression: 436case SyntaxKind.LessThanExpression: 437case SyntaxKind.GreaterThanOrEqualExpression: 438case SyntaxKind.LessThanOrEqualExpression: 439case SyntaxKind.BitwiseAndExpression: 440case SyntaxKind.BitwiseOrExpression: 441case SyntaxKind.ExclusiveOrExpression: 442case SyntaxKind.LeftShiftExpression: 443case SyntaxKind.RightShiftExpression: 444case SyntaxKind.UnsignedRightShiftExpression: 471if (node.IsKind(SyntaxKind.SubtractExpression) 472&& current.IsKind(SyntaxKind.ParenthesizedExpression)) 475&& !((ParenthesizedExpressionSyntax)current).Expression.IsKind(SyntaxKind.ParenthesizedExpression)) 483if (parenthesizedExpression.Expression.IsKind(SyntaxKind.IdentifierName) 595case SyntaxKind.EqualsExpression: 596case SyntaxKind.NotEqualsExpression: 597case SyntaxKind.LessThanExpression: 598case SyntaxKind.LessThanOrEqualExpression: 599case SyntaxKind.GreaterThanExpression: 600case SyntaxKind.GreaterThanOrEqualExpression: 784if (((SyntaxKind)node.OperatorToken.RawKind == SyntaxKind.PlusEqualsToken || (SyntaxKind)node.OperatorToken.RawKind == SyntaxKind.MinusEqualsToken) && 802bool isEquality = operatorToken.Kind() == SyntaxKind.EqualsEqualsToken || operatorToken.Kind() == SyntaxKind.ExclamationEqualsToken; 838case LookupResultKind.OverloadResolutionFailure when operatorToken.Kind() is SyntaxKind.PlusToken && isReadOnlySpanOfByte(left.Type) && isReadOnlySpanOfByte(right.Type): 860Debug.Assert(node.Kind() == SyntaxKind.LogicalOrExpression || node.Kind() == SyntaxKind.LogicalAndExpression); 873(childAsBinary.Kind() != SyntaxKind.LogicalOrExpression && childAsBinary.Kind() != SyntaxKind.LogicalAndExpression)) 2191public static BinaryOperatorKind SyntaxKindToBinaryOperatorKind(SyntaxKind kind) 2195case SyntaxKind.MultiplyAssignmentExpression: 2196case SyntaxKind.MultiplyExpression: return BinaryOperatorKind.Multiplication; 2197case SyntaxKind.DivideAssignmentExpression: 2198case SyntaxKind.DivideExpression: return BinaryOperatorKind.Division; 2199case SyntaxKind.ModuloAssignmentExpression: 2200case SyntaxKind.ModuloExpression: return BinaryOperatorKind.Remainder; 2201case SyntaxKind.AddAssignmentExpression: 2202case SyntaxKind.AddExpression: return BinaryOperatorKind.Addition; 2203case SyntaxKind.SubtractAssignmentExpression: 2204case SyntaxKind.SubtractExpression: return BinaryOperatorKind.Subtraction; 2205case SyntaxKind.RightShiftAssignmentExpression: 2206case SyntaxKind.RightShiftExpression: return BinaryOperatorKind.RightShift; 2207case SyntaxKind.UnsignedRightShiftAssignmentExpression: 2208case SyntaxKind.UnsignedRightShiftExpression: return BinaryOperatorKind.UnsignedRightShift; 2209case SyntaxKind.LeftShiftAssignmentExpression: 2210case SyntaxKind.LeftShiftExpression: return BinaryOperatorKind.LeftShift; 2211case SyntaxKind.EqualsExpression: return BinaryOperatorKind.Equal; 2212case SyntaxKind.NotEqualsExpression: return BinaryOperatorKind.NotEqual; 2213case SyntaxKind.GreaterThanExpression: return BinaryOperatorKind.GreaterThan; 2214case SyntaxKind.LessThanExpression: return BinaryOperatorKind.LessThan; 2215case SyntaxKind.GreaterThanOrEqualExpression: return BinaryOperatorKind.GreaterThanOrEqual; 2216case SyntaxKind.LessThanOrEqualExpression: return BinaryOperatorKind.LessThanOrEqual; 2217case SyntaxKind.AndAssignmentExpression: 2218case SyntaxKind.BitwiseAndExpression: return BinaryOperatorKind.And; 2219case SyntaxKind.OrAssignmentExpression: 2220case SyntaxKind.BitwiseOrExpression: return BinaryOperatorKind.Or; 2221case SyntaxKind.ExclusiveOrAssignmentExpression: 2222case SyntaxKind.ExclusiveOrExpression: return BinaryOperatorKind.Xor; 2223case SyntaxKind.LogicalAndExpression: return BinaryOperatorKind.LogicalAnd; 2224case SyntaxKind.LogicalOrExpression: return BinaryOperatorKind.LogicalOr; 2422Debug.Assert(node.Operand.SkipParens().GetLastToken().Kind() == SyntaxKind.ExclamationToken); 2965public static UnaryOperatorKind SyntaxKindToUnaryOperatorKind(SyntaxKind kind) 2969case SyntaxKind.PreIncrementExpression: return UnaryOperatorKind.PrefixIncrement; 2970case SyntaxKind.PostIncrementExpression: return UnaryOperatorKind.PostfixIncrement; 2971case SyntaxKind.PreDecrementExpression: return UnaryOperatorKind.PrefixDecrement; 2972case SyntaxKind.PostDecrementExpression: return UnaryOperatorKind.PostfixDecrement; 2973case SyntaxKind.UnaryPlusExpression: return UnaryOperatorKind.UnaryPlus; 2974case SyntaxKind.UnaryMinusExpression: return UnaryOperatorKind.UnaryMinus; 2975case SyntaxKind.LogicalNotExpression: return UnaryOperatorKind.LogicalNegation; 2976case SyntaxKind.BitwiseNotExpression: return UnaryOperatorKind.BitwiseComplement; 2981private static BindValueKind GetBinaryAssignmentKind(SyntaxKind kind) 2985case SyntaxKind.SimpleAssignmentExpression: 2987case SyntaxKind.AddAssignmentExpression: 2988case SyntaxKind.AndAssignmentExpression: 2989case SyntaxKind.DivideAssignmentExpression: 2990case SyntaxKind.ExclusiveOrAssignmentExpression: 2991case SyntaxKind.LeftShiftAssignmentExpression: 2992case SyntaxKind.ModuloAssignmentExpression: 2993case SyntaxKind.MultiplyAssignmentExpression: 2994case SyntaxKind.OrAssignmentExpression: 2995case SyntaxKind.RightShiftAssignmentExpression: 2996case SyntaxKind.UnsignedRightShiftAssignmentExpression: 2997case SyntaxKind.SubtractAssignmentExpression: 2998case SyntaxKind.CoalesceAssignmentExpression: 3005private static BindValueKind GetUnaryAssignmentKind(SyntaxKind kind) 3009case SyntaxKind.PreDecrementExpression: 3010case SyntaxKind.PreIncrementExpression: 3011case SyntaxKind.PostDecrementExpression: 3012case SyntaxKind.PostIncrementExpression: 3014case SyntaxKind.AddressOfExpression: 3036if (node.Kind() != SyntaxKind.UnaryMinusExpression) 3041if (node.Operand != operand.Syntax || operand.Syntax.Kind() != SyntaxKind.NumericLiteralExpression) 3134Error(diagnostics, ErrorCode.ERR_BadUnaryOp, node, SyntaxFacts.GetText(SyntaxKind.IsKeyword), operand.Display);

475case SyntaxKind.DefaultLiteralExpression: 479case SyntaxKind.ParenthesizedExpression: 482case SyntaxKind.SuppressNullableWarningExpression: 1215if (node.Designation?.Kind() == SyntaxKind.SingleVariableDesignation) 1314if ((inputType.IsPointerOrFunctionPointer() && node.Designation.Kind() == SyntaxKind.ParenthesizedVariableDesignation) 1342case SyntaxKind.DiscardDesignation: 1346case SyntaxKind.SingleVariableDesignation: 1357node.Parent.Kind() == SyntaxKind.VarPattern ? node.Parent : node, // for `var x` use whole pattern, otherwise use designation for the syntax 1361case SyntaxKind.ParenthesizedVariableDesignation: 1510case MemberAccessExpressionSyntax { Name: IdentifierNameSyntax name } memberAccess when memberAccess.IsKind(SyntaxKind.SimpleMemberAccessExpression): 1669static BinaryOperatorKind tokenKindToBinaryOperatorKind(SyntaxKind kind) => kind switch 1671SyntaxKind.LessThanEqualsToken => BinaryOperatorKind.LessThanOrEqual, 1672SyntaxKind.LessThanToken => BinaryOperatorKind.LessThan, 1673SyntaxKind.GreaterThanToken => BinaryOperatorKind.GreaterThan, 1674SyntaxKind.GreaterThanEqualsToken => BinaryOperatorKind.GreaterThanOrEqual, 1727bool isDisjunction = node.Kind() == SyntaxKind.OrPattern;

134case SyntaxKind.FromClause: 136case SyntaxKind.LetClause: 138case SyntaxKind.WhereClause: 140case SyntaxKind.JoinClause: 142case SyntaxKind.OrderByClause: 144return firstOrdering.IsKind(SyntaxKind.DescendingOrdering) ? "OrderByDescending" : "OrderBy"; 155case SyntaxKind.SelectClause: 157case SyntaxKind.GroupClause: 222case SyntaxKind.SelectClause: 243case SyntaxKind.GroupClause: 338case SyntaxKind.WhereClause: 341case SyntaxKind.JoinClause: 344case SyntaxKind.OrderByClause: 347case SyntaxKind.FromClause: 350case SyntaxKind.LetClause: 412if (state.clauses.IsEmpty() && state.selectOrGroup.Kind() == SyntaxKind.SelectClause) 566string methodName = (first ? "OrderBy" : "ThenBy") + (ordering.IsKind(SyntaxKind.DescendingOrdering) ? "Descending" : ""); 599if (state.clauses.IsEmpty() && state.selectOrGroup.IsKind(SyntaxKind.SelectClause))

138if (parent.Kind() == SyntaxKind.JoinClause) 154if (parent.Kind() == SyntaxKind.JoinClause) 170case SyntaxKind.JoinClause: 171clauseKind = SyntaxFacts.GetText(SyntaxKind.JoinKeyword); 174case SyntaxKind.LetClause: 175clauseKind = SyntaxFacts.GetText(SyntaxKind.LetKeyword); 177case SyntaxKind.SelectClause: 178clauseKind = SyntaxFacts.GetText(SyntaxKind.SelectKeyword); 180case SyntaxKind.WhereClause: 181clauseKind = SyntaxFacts.GetText(SyntaxKind.WhereKeyword); 183case SyntaxKind.OrderByClause: 184case SyntaxKind.AscendingOrdering: 185case SyntaxKind.DescendingOrdering: 186clauseKind = SyntaxFacts.GetText(SyntaxKind.OrderByKeyword); 189case SyntaxKind.QueryContinuation: 190clauseKind = SyntaxFacts.GetText(SyntaxKind.IntoKeyword); 192case SyntaxKind.GroupClause: 193clauseKind = SyntaxFacts.GetText(SyntaxKind.GroupKeyword) + " " + SyntaxFacts.GetText(SyntaxKind.ByKeyword); 196case SyntaxKind.FromClause: 201clauseKind = SyntaxFacts.GetText(SyntaxKind.FromKeyword);

46if (node.Kind() == SyntaxKind.LocalFunctionStatement) 50else if (node.Kind() != SyntaxKind.Block) 62case SyntaxKind.Block: 65case SyntaxKind.LocalDeclarationStatement: 68case SyntaxKind.LocalFunctionStatement: 71case SyntaxKind.ExpressionStatement: 74case SyntaxKind.IfStatement: 77case SyntaxKind.SwitchStatement: 80case SyntaxKind.DoStatement: 83case SyntaxKind.WhileStatement: 86case SyntaxKind.ForStatement: 89case SyntaxKind.ForEachStatement: 90case SyntaxKind.ForEachVariableStatement: 93case SyntaxKind.BreakStatement: 96case SyntaxKind.ContinueStatement: 99case SyntaxKind.ReturnStatement: 102case SyntaxKind.FixedStatement: 105case SyntaxKind.LabeledStatement: 108case SyntaxKind.GotoStatement: 109case SyntaxKind.GotoCaseStatement: 110case SyntaxKind.GotoDefaultStatement: 113case SyntaxKind.TryStatement: 116case SyntaxKind.EmptyStatement: 119case SyntaxKind.ThrowStatement: 122case SyntaxKind.UnsafeStatement: 125case SyntaxKind.UncheckedStatement: 126case SyntaxKind.CheckedStatement: 129case SyntaxKind.UsingStatement: 132case SyntaxKind.YieldBreakStatement: 135case SyntaxKind.YieldReturnStatement: 138case SyntaxKind.LockStatement: 322case SyntaxKind.LocalDeclarationStatement: 327goto case SyntaxKind.ExpressionStatement; 329case SyntaxKind.ExpressionStatement: 330case SyntaxKind.LockStatement: 331case SyntaxKind.IfStatement: 332case SyntaxKind.YieldReturnStatement: 333case SyntaxKind.ReturnStatement: 334case SyntaxKind.ThrowStatement: 339case SyntaxKind.LabeledStatement: 340case SyntaxKind.LocalFunctionStatement: 348case SyntaxKind.SwitchStatement: 354case SyntaxKind.EmptyStatement: 360case SyntaxKind.ForStatement: 361case SyntaxKind.ForEachStatement: 362case SyntaxKind.ForEachVariableStatement: 363case SyntaxKind.WhileStatement: 367if (emptyStatement.SemicolonToken.GetNextToken().Kind() != SyntaxKind.OpenBraceToken) 511case SyntaxKind.GotoStatement: 522case SyntaxKind.GotoCaseStatement: 523case SyntaxKind.GotoDefaultStatement: 597if (modifier.IsKind(SyntaxKind.StaticKeyword)) 599else if (modifier.IsKind(SyntaxKind.ExternKeyword)) 791declarationNode.Kind() == SyntaxKind.VariableDeclaration || 792declarationNode.Kind() == SyntaxKind.DeclarationExpression || 793declarationNode.Kind() == SyntaxKind.DiscardDesignation); 831if (declarationNode.Parent.Kind() == SyntaxKind.LocalDeclarationStatement && 886if (initializer.Kind() == SyntaxKind.ArrayInitializerExpression) 1419if (node.Left.Kind() == SyntaxKind.TupleExpression || node.Left.Kind() == SyntaxKind.DeclarationExpression) 1687case SyntaxKind.SimpleMemberAccessExpression: 1688case SyntaxKind.PointerMemberAccessExpression: 1691case SyntaxKind.IdentifierName: 1694case SyntaxKind.ElementAccessExpression: 1735case SyntaxKind.SimpleMemberAccessExpression: 1736case SyntaxKind.PointerMemberAccessExpression: 1738case SyntaxKind.QualifiedName: 1741case SyntaxKind.IdentifierName: 1743case SyntaxKind.MemberBindingExpression: 1819if (node.Kind() != SyntaxKind.ArrayInitializerExpression) 1891hasUnsafeModifier: node.Parent?.Kind() == SyntaxKind.UnsafeStatement, 2208if (sourceType.SpecialType == SpecialType.System_Double && syntax.Kind() == SyntaxKind.NumericLiteralExpression && 2407while (nodeForError.Kind() == SyntaxKind.ParenthesizedExpression) 2412if (nodeForError.Kind() == SyntaxKind.SimpleMemberAccessExpression || nodeForError.Kind() == SyntaxKind.PointerMemberAccessExpression) 3431return new BoundBlock(node, locals, ImmutableArray.Create(statement)) { WasCompilerGenerated = node.Kind() != SyntaxKind.ArrowExpressionClause }; 3436return IsValidStatementExpression(expressionSyntax, expression) || expressionSyntax.Kind() == SyntaxKind.ThrowExpression; 3500Debug.Assert(body.Kind() != SyntaxKind.RefExpression); 3526if (method.Kind() == SyntaxKind.ConstructorDeclaration) 3579Debug.Assert(typeDecl.Kind() is SyntaxKind.RecordDeclaration or SyntaxKind.ClassDeclaration); 3622bool thisInitializer = initializer?.IsKind(SyntaxKind.ThisConstructorInitializer) == true;

353if (node.Identifier.Kind() == SyntaxKind.GlobalKeyword) 410case SyntaxKind.NullableType: 413case SyntaxKind.PredefinedType: 416case SyntaxKind.IdentifierName: 419case SyntaxKind.GenericName: 422case SyntaxKind.AliasQualifiedName: 425case SyntaxKind.QualifiedName: 431case SyntaxKind.SimpleMemberAccessExpression: 437case SyntaxKind.ArrayType: 442case SyntaxKind.PointerType: 445case SyntaxKind.FunctionPointerType: 465case SyntaxKind.OmittedTypeArgument: 470case SyntaxKind.TupleType: 476case SyntaxKind.RefType: 498case SyntaxKind.ScopedType: 660if (!permitDimensions && dimension.Count != 0 && dimension[0].Kind() != SyntaxKind.OmittedArraySizeExpression) 697if (nameToken.Kind() == SyntaxKind.IdentifierToken) 834case SyntaxKind.IdentifierName: 837case SyntaxKind.GenericName: 936if (node.Parent.Kind() == SyntaxKind.Attribute) 1015(invocation.Expression as IdentifierNameSyntax)?.Identifier.ContextualKind() == SyntaxKind.NameOfKeyword): 1360var arg = typeArgument.Kind() == SyntaxKind.OmittedTypeArgument 1372if (typeArgumentsSyntax.Any(SyntaxKind.OmittedTypeArgument)) 1407if (!hasErrors && lookupResult.IsMultiViable && typeArgumentsSyntax.Any(SyntaxKind.OmittedTypeArgument)) 2262if (node.Kind() == SyntaxKind.AliasQualifiedName) 2536Debug.Assert(aliasOpt == null || aliasOpt == SyntaxFacts.GetText(SyntaxKind.GlobalKeyword));

29Debug.Assert((node.Kind() == SyntaxKind.SizeOfExpression) == ((object)sizeOfTypeOpt != null), "Should have a type for (only) sizeof expressions.");

280case SyntaxKind.PropertyDeclaration: 281case SyntaxKind.IndexerDeclaration: 286accessor = (parent.Kind() == SyntaxKind.GetAccessorDeclaration) ? propertySymbol.GetMethod : propertySymbol.SetMethod; 290case SyntaxKind.EventDeclaration: 291case SyntaxKind.EventFieldDeclaration: 299accessor = (parent.Kind() == SyntaxKind.AddAccessorDeclaration) ? eventSymbol.AddMethod : eventSymbol.RemoveMethod; 424if (node.Parent.Kind() == SyntaxKind.CompilationUnit && syntaxTree.Options.Kind != SourceCodeKind.Regular) 446case SyntaxKind.ConstructorDeclaration: 447return (baseMethodDeclarationSyntax.Modifiers.Any(SyntaxKind.StaticKeyword) ? WellKnownMemberNames.StaticConstructorName : WellKnownMemberNames.InstanceConstructorName); 448case SyntaxKind.DestructorDeclaration: 450case SyntaxKind.OperatorDeclaration: 453case SyntaxKind.ConversionOperatorDeclaration: 456case SyntaxKind.MethodDeclaration: 475case SyntaxKind.PropertyDeclaration: 478case SyntaxKind.IndexerDeclaration: 480case SyntaxKind.EventDeclaration: 481case SyntaxKind.EventFieldDeclaration: 509Debug.Assert(basePropertyDeclarationSyntax.Kind() == SyntaxKind.PropertyDeclaration || basePropertyDeclarationSyntax.Kind() == SyntaxKind.IndexerDeclaration); 686var container = ((NamespaceOrTypeSymbol)outer.ContainingMemberOrLambda).GetSourceTypeMember(parent.Identifier.ValueText, 0, SyntaxKind.EnumDeclaration, parent); 842if (InScript && container.Kind() == SyntaxKind.CompilationUnit) 1012Debug.Assert(declarationSyntax.Kind() is SyntaxKind.CompilationUnit or SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration); 1045if (containingNode.Kind() != SyntaxKind.CompilationUnit && _position == containingSpan.End) 1067if (node.IsKind(SyntaxKind.UsingDirective) && node.Parent == containingNode) 1237SyntaxKind memberKind = memberSyntax.Kind(); 1238if (memberKind == SyntaxKind.PropertyDeclaration || memberKind == SyntaxKind.IndexerDeclaration) 1260else if (memberKind == SyntaxKind.DelegateDeclaration) 1306if (memberSyntax.Kind() == SyntaxKind.MethodDeclaration) 1316else if (memberSyntax.Kind() == SyntaxKind.DelegateDeclaration) 1359if (baseTypeDeclaration is TypeDeclarationSyntax { SemicolonToken: { RawKind: (int)SyntaxKind.SemicolonToken }, OpenBraceToken: { RawKind: (int)SyntaxKind.None } } noBlockBodyTypeDeclarationWithSemicolon) 1391Debug.Assert(xmlSyntax is XmlAttributeSyntax || xmlSyntax.Kind() == SyntaxKind.XmlEmptyElement || xmlSyntax.Kind() == SyntaxKind.XmlElementStartTag);

114if ((!InScript || node.Kind() != SyntaxKind.CompilationUnit) && node.Parent != null) 174case SyntaxKind.NamespaceDeclaration: 175case SyntaxKind.FileScopedNamespaceDeclaration: 184case SyntaxKind.CompilationUnit:

32if ((declarationOpt != null) && (declarationOpt.Identifier.Kind() != SyntaxKind.None))

150if (label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 2064if (e.Syntax.IsKind(SyntaxKind.ListPattern))

63case SyntaxKind.ObjectCreationExpression: 64case SyntaxKind.ImplicitObjectCreationExpression: 71case SyntaxKind.SizeOfExpression: 74case SyntaxKind.TypeOfExpression: 81case SyntaxKind.NumericLiteralExpression: 82case SyntaxKind.StringLiteralExpression: 83case SyntaxKind.Utf8StringLiteralExpression: 84case SyntaxKind.InterpolatedStringExpression: 85case SyntaxKind.CharacterLiteralExpression: 86case SyntaxKind.TrueLiteralExpression: 87case SyntaxKind.FalseLiteralExpression: 88case SyntaxKind.NullLiteralExpression: 92case SyntaxKind.IdentifierName: 93case SyntaxKind.GenericName: 94case SyntaxKind.AliasQualifiedName: 95case SyntaxKind.QualifiedName: 96case SyntaxKind.PredefinedType: 97case SyntaxKind.SimpleMemberAccessExpression: 102case SyntaxKind.ParenthesizedExpression: 105case SyntaxKind.CastExpression: 108case SyntaxKind.UncheckedExpression: 109case SyntaxKind.CheckedExpression: 112case SyntaxKind.DefaultExpression: 115case SyntaxKind.UnaryPlusExpression: 116case SyntaxKind.UnaryMinusExpression: 117case SyntaxKind.LogicalNotExpression: 118case SyntaxKind.BitwiseNotExpression: 121case SyntaxKind.AddExpression: 122case SyntaxKind.MultiplyExpression: 123case SyntaxKind.SubtractExpression: 124case SyntaxKind.DivideExpression: 125case SyntaxKind.ModuloExpression: 126case SyntaxKind.LeftShiftExpression: 127case SyntaxKind.RightShiftExpression: 128case SyntaxKind.UnsignedRightShiftExpression: 129case SyntaxKind.BitwiseAndExpression: 130case SyntaxKind.BitwiseOrExpression: 131case SyntaxKind.ExclusiveOrExpression: 132case SyntaxKind.LogicalAndExpression: 133case SyntaxKind.LogicalOrExpression: 134case SyntaxKind.EqualsExpression: 135case SyntaxKind.NotEqualsExpression: 136case SyntaxKind.GreaterThanExpression: 137case SyntaxKind.LessThanExpression: 138case SyntaxKind.GreaterThanOrEqualExpression: 139case SyntaxKind.LessThanOrEqualExpression: 140case SyntaxKind.InvocationExpression: // To support nameof(); anything else will be a compile-time error 141case SyntaxKind.ConditionalExpression: // The ?: conditional operator.

37case SyntaxKind.EqualsValueClause: 38case SyntaxKind.ArrowExpressionClause: 39case SyntaxKind.SwitchSection: 40case SyntaxKind.Attribute: 41case SyntaxKind.ThrowStatement: 42case SyntaxKind.ReturnStatement: 43case SyntaxKind.YieldReturnStatement: 44case SyntaxKind.ExpressionStatement: 45case SyntaxKind.LockStatement: 46case SyntaxKind.IfStatement: 47case SyntaxKind.SwitchStatement: 48case SyntaxKind.VariableDeclarator: 49case SyntaxKind.ConstructorDeclaration: 50case SyntaxKind.SwitchExpressionArm: 51case SyntaxKind.GotoCaseStatement: 52case SyntaxKind.PrimaryConstructorBaseType: 54case SyntaxKind.ArgumentList: 108if (node.Kind() == SyntaxKind.GotoCaseStatement) 152case SyntaxKind.CasePatternSwitchLabel: 166case SyntaxKind.CaseSwitchLabel: 224if (node.Designation?.Kind() == SyntaxKind.SingleVariableDesignation) 235Debug.Assert(node.Designation == null || node.Designation.Kind() == SyntaxKind.DiscardDesignation); 251case SyntaxKind.SingleVariableDesignation: 258case SyntaxKind.DiscardDesignation: 260case SyntaxKind.ParenthesizedVariableDesignation: 316if (clause.Kind() == SyntaxKind.JoinClause) 363case SyntaxKind.SingleVariableDesignation: 371case SyntaxKind.DiscardDesignation: 374case SyntaxKind.ParenthesizedVariableDesignation: 414case SyntaxKind.TupleExpression: 423case SyntaxKind.DeclarationExpression: 444case SyntaxKind.SingleVariableDesignation: 454case SyntaxKind.ParenthesizedVariableDesignation: 463case SyntaxKind.DiscardDesignation:

39if (size.Kind() != SyntaxKind.OmittedArraySizeExpression)

40return (_syntax.Kind() == SyntaxKind.ForEachStatement) ? (SourceLocalSymbol)this.Locals[0] : null; 58case SyntaxKind.ForEachVariableStatement: 69case SyntaxKind.ForEachStatement: 94case SyntaxKind.TupleExpression: 103case SyntaxKind.DeclarationExpression: 112case SyntaxKind.IdentifierName: 131case SyntaxKind.SingleVariableDesignation: 145case SyntaxKind.ParenthesizedVariableDesignation: 154case SyntaxKind.DiscardDesignation: 257case SyntaxKind.ForEachStatement: 345case SyntaxKind.ForEachVariableStatement:

39if (size.Kind() != SyntaxKind.OmittedArraySizeExpression)

60if (size.Kind() != SyntaxKind.OmittedArraySizeExpression) 93else if (syntax.Kind() != SyntaxKind.Block && (statement = syntax as StatementSyntax) != null) 127if (member.Kind() == SyntaxKind.GlobalStatement) 176Debug.Assert(node.Kind() is SyntaxKind.RecordDeclaration or SyntaxKind.ClassDeclaration); 347if (body.Kind() == SyntaxKind.Block) 624Binder binder = _enclosing.WithCheckedOrUncheckedRegion(@checked: node.Kind() == SyntaxKind.CheckedExpression); 631Binder binder = _enclosing.WithCheckedOrUncheckedRegion(@checked: node.Kind() == SyntaxKind.CheckedStatement); 705case SyntaxKind.CasePatternSwitchLabel: 715case SyntaxKind.CaseSwitchLabel: 945case SyntaxKind.LocalDeclarationStatement: 946case SyntaxKind.LabeledStatement: 947case SyntaxKind.LocalFunctionStatement: 951case SyntaxKind.ExpressionStatement: 952case SyntaxKind.LockStatement: 953case SyntaxKind.IfStatement: 954case SyntaxKind.YieldReturnStatement: 955case SyntaxKind.ReturnStatement: 956case SyntaxKind.ThrowStatement: 961case SyntaxKind.SwitchStatement: 1004if (clause.Kind() == SyntaxKind.JoinClause)

176while (innerStatement.Kind() == SyntaxKind.LabeledStatement) 183case SyntaxKind.LocalDeclarationStatement: 192if (expression.Kind() != SyntaxKind.OmittedArraySizeExpression) 224case SyntaxKind.ExpressionStatement: 225case SyntaxKind.IfStatement: 226case SyntaxKind.YieldReturnStatement: 227case SyntaxKind.ReturnStatement: 228case SyntaxKind.ThrowStatement: 229case SyntaxKind.GotoCaseStatement: 233case SyntaxKind.SwitchStatement: 238case SyntaxKind.LockStatement: 267while (innerStatement.Kind() == SyntaxKind.LabeledStatement) 272if (innerStatement.Kind() == SyntaxKind.LocalFunctionStatement) 318while (statement.Kind() == SyntaxKind.LabeledStatement)

44Debug.Assert(targetExpressionSyntax.Parent.Kind() == SyntaxKind.LockStatement || 45targetExpressionSyntax.Parent.Kind() == SyntaxKind.UsingStatement); 54if (targetExpressionSyntax.Kind() == SyntaxKind.IdentifierName)

84if (member.Kind() != SyntaxKind.GlobalStatement)

1533if (anonymousFunction.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression) 1613var greenNode = new Syntax.InternalSyntax.LiteralExpressionSyntax(SyntaxKind.NumericLiteralExpression, new Syntax.InternalSyntax.SyntaxToken(SyntaxKind.NumericLiteralToken));

63public static string BinaryOperatorNameFromSyntaxKind(SyntaxKind kind, bool isChecked) 69internal static string BinaryOperatorNameFromSyntaxKindIfAny(SyntaxKind kind, bool isChecked) 73case SyntaxKind.PlusToken: return isChecked ? WellKnownMemberNames.CheckedAdditionOperatorName : WellKnownMemberNames.AdditionOperatorName; 74case SyntaxKind.MinusToken: return isChecked ? WellKnownMemberNames.CheckedSubtractionOperatorName : WellKnownMemberNames.SubtractionOperatorName; 75case SyntaxKind.AsteriskToken: return isChecked ? WellKnownMemberNames.CheckedMultiplyOperatorName : WellKnownMemberNames.MultiplyOperatorName; 76case SyntaxKind.SlashToken: return isChecked ? WellKnownMemberNames.CheckedDivisionOperatorName : WellKnownMemberNames.DivisionOperatorName; 77case SyntaxKind.PercentToken: return WellKnownMemberNames.ModulusOperatorName; 78case SyntaxKind.CaretToken: return WellKnownMemberNames.ExclusiveOrOperatorName; 79case SyntaxKind.AmpersandToken: return WellKnownMemberNames.BitwiseAndOperatorName; 80case SyntaxKind.BarToken: return WellKnownMemberNames.BitwiseOrOperatorName; 81case SyntaxKind.EqualsEqualsToken: return WellKnownMemberNames.EqualityOperatorName; 82case SyntaxKind.LessThanToken: return WellKnownMemberNames.LessThanOperatorName; 83case SyntaxKind.LessThanEqualsToken: return WellKnownMemberNames.LessThanOrEqualOperatorName; 84case SyntaxKind.LessThanLessThanToken: return WellKnownMemberNames.LeftShiftOperatorName; 85case SyntaxKind.GreaterThanToken: return WellKnownMemberNames.GreaterThanOperatorName; 86case SyntaxKind.GreaterThanEqualsToken: return WellKnownMemberNames.GreaterThanOrEqualOperatorName; 87case SyntaxKind.GreaterThanGreaterThanToken: return WellKnownMemberNames.RightShiftOperatorName; 88case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: return WellKnownMemberNames.UnsignedRightShiftOperatorName; 89case SyntaxKind.ExclamationEqualsToken: return WellKnownMemberNames.InequalityOperatorName; 95public static string UnaryOperatorNameFromSyntaxKind(SyntaxKind kind, bool isChecked) 101internal static string UnaryOperatorNameFromSyntaxKindIfAny(SyntaxKind kind, bool isChecked) 105case SyntaxKind.PlusToken: return WellKnownMemberNames.UnaryPlusOperatorName; 106case SyntaxKind.MinusToken: return isChecked ? WellKnownMemberNames.CheckedUnaryNegationOperatorName : WellKnownMemberNames.UnaryNegationOperatorName; 107case SyntaxKind.TildeToken: return WellKnownMemberNames.OnesComplementOperatorName; 108case SyntaxKind.ExclamationToken: return WellKnownMemberNames.LogicalNotOperatorName; 109case SyntaxKind.PlusPlusToken: return isChecked ? WellKnownMemberNames.CheckedIncrementOperatorName : WellKnownMemberNames.IncrementOperatorName; 110case SyntaxKind.MinusMinusToken: return isChecked ? WellKnownMemberNames.CheckedDecrementOperatorName : WellKnownMemberNames.DecrementOperatorName; 111case SyntaxKind.TrueKeyword: return WellKnownMemberNames.TrueOperatorName; 112case SyntaxKind.FalseKeyword: return WellKnownMemberNames.FalseOperatorName; 125var opTokenKind = declaration.OperatorToken.Kind; 126bool isChecked = declaration.CheckedKeyword?.Kind == SyntaxKind.CheckedKeyword; 131if (opTokenKind != SyntaxKind.AsteriskToken && // IsPrefixUnaryExpressionOperatorToken treats it as pointer dereference operator 160case SyntaxKind.ImplicitKeyword: 163return declaration.CheckedKeyword?.Kind == SyntaxKind.CheckedKeyword ?

647else if (nodeOpt?.Kind() == SyntaxKind.AwaitExpression && symbol.Name == WellKnownMemberNames.GetAwaiter) 884badParamName = SyntaxFacts.GetText(SyntaxKind.ArgListKeyword);

96SyntaxKind labelKind = label.IdentifierNodeOrToken.Kind(); 97if (labelKind == SyntaxKind.IdentifierToken) 109else if (labelKind == SyntaxKind.DefaultSwitchLabel) 204case SyntaxKind.CaseSwitchLabel: 219case SyntaxKind.CasePatternSwitchLabel: 470Debug.Assert(node.Kind() == SyntaxKind.GotoCaseStatement || node.Kind() == SyntaxKind.GotoDefaultStatement); 490Debug.Assert(node.Kind() == SyntaxKind.GotoCaseStatement); 515Debug.Assert(node.Kind() == SyntaxKind.GotoDefaultStatement); 525if (node.Kind() == SyntaxKind.GotoCaseStatement)

97if (!label.HasErrors && isSubsumed(label, reachableLabels) && label.Syntax.Kind() != SyntaxKind.DefaultSwitchLabel) 236case SyntaxKind.CaseSwitchLabel: 248case SyntaxKind.DefaultSwitchLabel: 266case SyntaxKind.CasePatternSwitchLabel:

49if (size.Kind() != SyntaxKind.OmittedArraySizeExpression) 92bool isUsingDeclaration = syntax.Kind() == SyntaxKind.LocalDeclarationStatement; 93bool isExpression = !isUsingDeclaration && syntax.Kind() != SyntaxKind.VariableDeclaration;

24Debug.Assert(syntax != null && (syntax.IsKind(SyntaxKind.WhileStatement) || syntax.IsKind(SyntaxKind.DoStatement))); 55case SyntaxKind.WhileStatement: 58case SyntaxKind.DoStatement:

50case SyntaxKind.TypeCref: 55case SyntaxKind.QualifiedCref: 62case SyntaxKind.NameMemberCref: 63case SyntaxKind.IndexerMemberCref: 64case SyntaxKind.OperatorMemberCref: 65case SyntaxKind.ConversionOperatorMemberCref: 82case SyntaxKind.AliasQualifiedName: 85case SyntaxKind.QualifiedName: 92case SyntaxKind.GenericName: 95case SyntaxKind.IdentifierName: 96case SyntaxKind.PredefinedType: 106if (memberSyntax.Kind() == SyntaxKind.NameMemberCref) 124if (typeArguments[i].Kind() == SyntaxKind.IdentifierName)

91Debug.Assert(declarationSyntax.Kind() is SyntaxKind.CompilationUnit or SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration);

120Debug.Assert(declarationSyntax.Kind() is SyntaxKind.CompilationUnit or SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration);

276Debug.Assert(declarationSyntax.Kind() is SyntaxKind.CompilationUnit or SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration); 306Debug.Assert(declarationSyntax.IsKind(SyntaxKind.CompilationUnit) || declarationSyntax.IsKind(SyntaxKind.NamespaceDeclaration));

72public MessageID MessageID { get { return Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 1454public override MessageID MessageID { get { return this.UnboundLambda.Syntax.Kind() == SyntaxKind.AnonymousMethodExpression ? MessageID.IDS_AnonMethod : MessageID.IDS_Lambda; } } 1471case SyntaxKind.SimpleLambdaExpression: 1473case SyntaxKind.ParenthesizedLambdaExpression: 1475case SyntaxKind.AnonymousMethodExpression: 1480private bool IsExpressionLambda { get { return Body.Kind() != SyntaxKind.Block; } }

37Debug.Assert(this.Syntax.Kind() == SyntaxKind.SingleVariableDesignation || 38(this.Syntax.Kind() == SyntaxKind.DeclarationExpression && 39((DeclarationExpressionSyntax)this.Syntax).Designation.Kind() == SyntaxKind.SingleVariableDesignation)); 61SyntaxNode typeOrDesignationSyntax = this.Syntax.Kind() == SyntaxKind.DeclarationExpression ? 122case SyntaxKind.DeclarationExpression: 125case SyntaxKind.SingleVariableDesignation:

777(local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection || local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchExpressionArm)); 822return _ilEmitStyle == ILEmitStyle.Debug && _method.GenerateDebugInfo && _methodBodySyntaxOpt?.IsKind(SyntaxKind.Block) == true || 833(boundReturnStatement.Syntax.IsKind(SyntaxKind.Block) || _method?.IsImplicitConstructor == true) && 1809(local.ScopeDesignatorOpt?.Kind() is SyntaxKind.SwitchSection or SyntaxKind.SwitchExpressionArm)))

350d => d.IsActive && !d.HasErrors && d.Kind() == SyntaxKind.LineDirectiveTrivia))

65case SyntaxKind.Attribute: 68case SyntaxKind.AttributeArgument: 87if (node.Kind() == SyntaxKind.Attribute)

770if (root.DescendantNodes(n => n is GlobalStatementSyntax || n is StatementSyntax || n is CompilationUnitSyntax).Any(n => n.IsKind(SyntaxKind.ReturnStatement))) 776var lastGlobalStatement = (GlobalStatementSyntax?)root.Members.LastOrDefault(m => m.IsKind(SyntaxKind.GlobalStatement)); 780if (statement.IsKind(SyntaxKind.ExpressionStatement)) 2402ErrorCode code = info.Kind == SyntaxKind.ExternAliasDirective 2416else if (info.Kind == SyntaxKind.ExternAliasDirective) 2525public readonly SyntaxKind Kind; 2528public ImportInfo(SyntaxTree tree, SyntaxKind kind, TextSpan span) 3495var checksumDirectives = tree.GetRoot().GetDirectives(d => d.Kind() == SyntaxKind.PragmaChecksumDirectiveTrivia && 3925var syntaxKind = SyntaxFacts.GetOperatorKind(name); 3926if (syntaxKind == SyntaxKind.None) 4148var syntaxKind = SyntaxFacts.GetOperatorKind(name); 4152if (syntaxKind == SyntaxKind.None || name is WellKnownMemberNames.TrueOperatorName or WellKnownMemberNames.FalseOperatorName) 4441Func<SyntaxNode, SyntaxKind> getKind = node => node.Kind(); 4442Func<SyntaxTrivia, bool> isComment = trivia => trivia.Kind() == SyntaxKind.SingleLineCommentTrivia || trivia.Kind() == SyntaxKind.MultiLineCommentTrivia; 4443return new AnalyzerDriver<SyntaxKind>(analyzers, getKind, analyzerManager, severityFilter, isComment);

70case SyntaxKind.CollectionInitializerExpression: 71case SyntaxKind.ObjectInitializerExpression: 83case SyntaxKind.ComplexElementInitializerExpression: 91case SyntaxKind.IdentifierName: 93if (!isSpeculative && node.Parent != null && node.Parent.Kind() == SyntaxKind.NameEquals && node.Parent.Parent.Kind() == SyntaxKind.UsingDirective) 100case SyntaxKind.OmittedTypeArgument: 101case SyntaxKind.RefExpression: 102case SyntaxKind.RefType: 103case SyntaxKind.ScopedType: 303if (expression.IsKind(SyntaxKind.QualifiedName)) 345while (crefSyntax.Kind() == SyntaxKind.QualifiedCref) 352case SyntaxKind.NameMemberCref: 354case SyntaxKind.IndexerMemberCref: 356case SyntaxKind.OperatorMemberCref: 358case SyntaxKind.ConversionOperatorMemberCref: 536case SyntaxKind.SingleVariableDesignation: 539case SyntaxKind.DiscardDesignation: 542case SyntaxKind.ParenthesizedVariableDesignation: 559if (declaration.Designation.Kind() != SyntaxKind.SingleVariableDesignation) 612if (expression.Parent != null && expression.Parent.Kind() == SyntaxKind.CollectionInitializerExpression) 620initializer.Parent.Kind() == SyntaxKind.SimpleAssignmentExpression && 623initializer.Parent.Parent.Kind() == SyntaxKind.ObjectInitializerExpression) 962case SyntaxKind.SingleVariableDesignation: 968case SyntaxKind.DiscardDesignation: 972case SyntaxKind.ParenthesizedVariableDesignation: 1240if (node.Kind() == SyntaxKind.XmlCrefAttribute || node.Kind() == SyntaxKind.XmlNameAttribute) 1868if (curr.IsKind(SyntaxKind.TypeOfExpression)) 2060boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 2392return parent.IsKind(SyntaxKind.GotoStatement) 2828if (expression.Kind() == SyntaxKind.DeclarationExpression) 3296Debug.Assert(catchClause.Kind() == SyntaxKind.CatchClause); 3363if (expr.Syntax.Kind() is SyntaxKind.ObjectCreationExpression or SyntaxKind.ImplicitObjectCreationExpression) 3390boundNodeForSyntacticParent.Syntax.Kind() == SyntaxKind.ObjectCreationExpression && 3964parentSyntax.Kind() == SyntaxKind.Attribute && ((AttributeSyntax)parentSyntax).Name == boundNode.Syntax) 4472if (parent3.IsKind(SyntaxKind.TupleExpression)) 4479if (parent3.IsKind(SyntaxKind.PropertyPatternClause) || parent3.IsKind(SyntaxKind.PositionalPatternClause)) 5069case SyntaxKind.LocalFunctionStatement: 5071case SyntaxKind.LabeledStatement: 5073case SyntaxKind.CaseSwitchLabel: 5074case SyntaxKind.DefaultSwitchLabel: 5076case SyntaxKind.AnonymousObjectCreationExpression: 5078case SyntaxKind.AnonymousObjectMemberDeclarator: 5080case SyntaxKind.TupleExpression: 5082case SyntaxKind.Argument: 5084case SyntaxKind.VariableDeclarator: 5086case SyntaxKind.SingleVariableDesignation: 5088case SyntaxKind.TupleElement: 5090case SyntaxKind.NamespaceDeclaration: 5092case SyntaxKind.FileScopedNamespaceDeclaration: 5094case SyntaxKind.Parameter: 5096case SyntaxKind.TypeParameter: 5098case SyntaxKind.UsingDirective: 5106case SyntaxKind.ForEachStatement: 5108case SyntaxKind.CatchDeclaration: 5110case SyntaxKind.JoinIntoClause: 5112case SyntaxKind.QueryContinuation: 5114case SyntaxKind.CompilationUnit:

42Debug.Assert(syntax.IsKind(SyntaxKind.VariableDeclarator) || syntax.IsKind(SyntaxKind.EnumMemberDeclaration)); 52Debug.Assert(syntax.IsKind(SyntaxKind.PropertyDeclaration)); 84case SyntaxKind.VariableDeclarator: 88case SyntaxKind.Parameter: 92case SyntaxKind.EqualsValueClause: 96case SyntaxKind.EnumMemberDeclaration: 100case SyntaxKind.PropertyDeclaration: 117case SyntaxKind.EqualsValueClause: 121case SyntaxKind.VariableDeclarator: 125case SyntaxKind.PropertyDeclaration: 129case SyntaxKind.Parameter: 133case SyntaxKind.EnumMemberDeclaration: 194case SyntaxKind.EqualsValueClause:

229SyntaxKind kind = current.Kind(); 241else if (kind == SyntaxKind.LocalFunctionStatement) 252else if (kind == SyntaxKind.CatchClause) 259else if (kind == SyntaxKind.CatchFilterClause) 274else if (kind == SyntaxKind.TypeOfExpression && 283else if (kind == SyntaxKind.SwitchSection) 290else if (kind == SyntaxKind.ArgumentList) 299else if (kind == SyntaxKind.EqualsValueClause) 303else if (kind == SyntaxKind.Attribute) 307else if (kind == SyntaxKind.ArrowExpressionClause) 311else if (kind == SyntaxKind.ThisConstructorInitializer || kind == SyntaxKind.BaseConstructorInitializer || kind == SyntaxKind.PrimaryConstructorBaseType) 315else if (kind == SyntaxKind.ConstructorDeclaration) 319else if (kind == SyntaxKind.SwitchExpression) 323else if (kind == SyntaxKind.SwitchExpressionArm) 379case SyntaxKind.SwitchStatement: 388case SyntaxKind.ForStatement: 404case SyntaxKind.ForEachStatement: 405case SyntaxKind.ForEachVariableStatement: 407var start = stmt.Kind() == SyntaxKind.ForEachVariableStatement ? foreachStmt.InKeyword : foreachStmt.OpenParenToken; 431if (expression.Kind() == SyntaxKind.DeclarationExpression) 840else if (paramList.Parent.Kind() == SyntaxKind.LocalFunctionStatement) 907if (node.Kind() != SyntaxKind.AwaitExpression) 1323if (bindableParent != null && bindableParent.Kind() == SyntaxKind.SimpleMemberAccessExpression && ((MemberAccessExpressionSyntax)bindableParent).Expression == bindableNode) 1538case SyntaxKind.ThisConstructorInitializer: 1539case SyntaxKind.BaseConstructorInitializer: 1540case SyntaxKind.PrimaryConstructorBaseType: 1542case SyntaxKind.ArrowExpressionClause: 1545if (current.Parent == null || current.Parent.Kind() != SyntaxKind.LocalFunctionStatement) 2139case SyntaxKind.GetAccessorDeclaration: 2140case SyntaxKind.SetAccessorDeclaration: 2141case SyntaxKind.InitAccessorDeclaration: 2142case SyntaxKind.AddAccessorDeclaration: 2143case SyntaxKind.RemoveAccessorDeclaration: 2144case SyntaxKind.MethodDeclaration: 2145case SyntaxKind.ConstructorDeclaration: 2146case SyntaxKind.DestructorDeclaration: 2147case SyntaxKind.OperatorDeclaration: 2148case SyntaxKind.ConversionOperatorDeclaration: 2149case SyntaxKind.GlobalStatement: 2150case SyntaxKind.Subpattern: 2152case SyntaxKind.PositionalPatternClause: 2169case PostfixUnaryExpressionSyntax { RawKind: (int)SyntaxKind.SuppressNullableWarningExpression } n: 2190case SyntaxKind.IdentifierName: 2191case SyntaxKind.GenericName: 2200case SyntaxKind.AnonymousObjectMemberDeclarator: 2203case SyntaxKind.VariableDeclarator: // declarators are mapped in SyntaxBinder 2209Debug.Assert(parent.Kind() == SyntaxKind.VariableDeclaration); 2211if (grandparent != null && grandparent.Kind() == SyntaxKind.LocalDeclarationStatement && 2271case SyntaxKind.ParenthesizedExpression: 2272case SyntaxKind.RefExpression: 2273case SyntaxKind.RefType: 2274case SyntaxKind.ScopedType: 2292if ((bindableParent.Kind() == SyntaxKind.SimpleMemberAccessExpression) && (bindableParent.Parent.Kind() == SyntaxKind.InvocationExpression)) 2296else if (bindableParent.Kind() == SyntaxKind.ArrayType)

58Debug.Assert((syntax.Kind() == SyntaxKind.CompilationUnit) == (!IsSpeculativeSemanticModel && owner is SynthesizedSimpleProgramEntryPointSymbol)); 81case SyntaxKind.ArrowExpressionClause: 84case SyntaxKind.BaseConstructorInitializer: 85case SyntaxKind.ThisConstructorInitializer: 88case SyntaxKind.PrimaryConstructorBaseType: 91case SyntaxKind.MethodDeclaration: 92case SyntaxKind.ConversionOperatorDeclaration: 93case SyntaxKind.OperatorDeclaration: 94case SyntaxKind.ConstructorDeclaration: 95case SyntaxKind.DestructorDeclaration: 96case SyntaxKind.GetAccessorDeclaration: 97case SyntaxKind.SetAccessorDeclaration: 98case SyntaxKind.InitAccessorDeclaration: 99case SyntaxKind.AddAccessorDeclaration: 100case SyntaxKind.RemoveAccessorDeclaration: 101case SyntaxKind.CompilationUnit: 102case SyntaxKind.RecordDeclaration: 103case SyntaxKind.ClassDeclaration: 265Debug.Assert(typeDecl.Kind() is (SyntaxKind.RecordDeclaration or SyntaxKind.ClassDeclaration));

146var attributeOrParameter = node.FirstAncestorOrSelf<SyntaxNode>(static n => n.Kind() is SyntaxKind.Attribute or SyntaxKind.Parameter);

243else if (node.Parent.Kind() == SyntaxKind.XmlNameAttribute && (attrSyntax = (XmlNameAttributeSyntax)node.Parent).Identifier == node) 504if (parent is BaseTypeSyntax baseType && parent.Parent != null && parent.Parent.Kind() == SyntaxKind.BaseList && baseType.Type == expression) 520if (expression.Kind() == SyntaxKind.DeclarationExpression) 784case SyntaxKind.AddAccessorDeclaration: 785case SyntaxKind.RemoveAccessorDeclaration: 786case SyntaxKind.GetAccessorDeclaration: 787case SyntaxKind.SetAccessorDeclaration: 788case SyntaxKind.InitAccessorDeclaration: 792case SyntaxKind.ConstructorDeclaration: 798case SyntaxKind.ClassDeclaration: 799case SyntaxKind.RecordDeclaration: 814case SyntaxKind.ConversionOperatorDeclaration: 815case SyntaxKind.DestructorDeclaration: 816case SyntaxKind.MethodDeclaration: 817case SyntaxKind.OperatorDeclaration: 848case SyntaxKind.MethodDeclaration: 849case SyntaxKind.ConversionOperatorDeclaration: 850case SyntaxKind.OperatorDeclaration: 858case SyntaxKind.ConstructorDeclaration: 868case SyntaxKind.ClassDeclaration: 869case SyntaxKind.RecordDeclaration: 877case SyntaxKind.DestructorDeclaration: 885case SyntaxKind.GetAccessorDeclaration: 886case SyntaxKind.SetAccessorDeclaration: 887case SyntaxKind.InitAccessorDeclaration: 888case SyntaxKind.AddAccessorDeclaration: 889case SyntaxKind.RemoveAccessorDeclaration: 897case SyntaxKind.IndexerDeclaration: 903case SyntaxKind.FieldDeclaration: 904case SyntaxKind.EventFieldDeclaration: 918case SyntaxKind.EnumMemberDeclaration: 926case SyntaxKind.PropertyDeclaration: 933case SyntaxKind.GlobalStatement: 941case SyntaxKind.CompilationUnit: 948case SyntaxKind.Attribute: 951case SyntaxKind.Parameter: 1072case SyntaxKind.CompilationUnit: 1075case SyntaxKind.MethodDeclaration: 1076case SyntaxKind.ConversionOperatorDeclaration: 1077case SyntaxKind.OperatorDeclaration: 1078case SyntaxKind.ConstructorDeclaration: 1079case SyntaxKind.DestructorDeclaration: 1086case SyntaxKind.ClassDeclaration: 1087case SyntaxKind.RecordDeclaration: 1099case SyntaxKind.GetAccessorDeclaration: 1100case SyntaxKind.SetAccessorDeclaration: 1101case SyntaxKind.InitAccessorDeclaration: 1102case SyntaxKind.AddAccessorDeclaration: 1103case SyntaxKind.RemoveAccessorDeclaration: 1110case SyntaxKind.Block: 1115case SyntaxKind.EqualsValueClause: 1118case SyntaxKind.VariableDeclarator: 1131case SyntaxKind.PropertyDeclaration: 1142case SyntaxKind.Parameter: 1159case SyntaxKind.EnumMemberDeclaration: 1176case SyntaxKind.ArrowExpressionClause: 1202case SyntaxKind.GlobalStatement: 1206if (parent.Kind() == SyntaxKind.CompilationUnit && 1231case SyntaxKind.Attribute: 1271case SyntaxKind.FieldDeclaration: 1274case SyntaxKind.EventFieldDeclaration: 1298(node.Kind() == SyntaxKind.Attribute) || (node.Kind() == SyntaxKind.Parameter); 1332if (declarationSyntax.Parent.Kind() == SyntaxKind.CompilationUnit) 1454case SyntaxKind.GlobalStatement: 1458case SyntaxKind.IncompleteMember: 1462case SyntaxKind.EventFieldDeclaration: 1463case SyntaxKind.FieldDeclaration: 1577if (declarationSyntax.Kind() == SyntaxKind.UnknownAccessorDeclaration) 1587case SyntaxKind.PropertyDeclaration: 1588case SyntaxKind.IndexerDeclaration: 1589case SyntaxKind.EventDeclaration: 1590case SyntaxKind.EventFieldDeclaration: 1595Debug.Assert(declarationSyntax.Keyword.Kind() != SyntaxKind.IdentifierToken); 1612case SyntaxKind.PropertyDeclaration: 1613case SyntaxKind.IndexerDeclaration: 1632case SyntaxKind.MethodDeclaration: 1638case SyntaxKind.PropertyDeclaration: 1644case SyntaxKind.IndexerDeclaration: 1650case SyntaxKind.EventDeclaration: 1656case SyntaxKind.DelegateDeclaration: 1659case SyntaxKind.InterfaceDeclaration: 1660case SyntaxKind.StructDeclaration: 1661case SyntaxKind.ClassDeclaration: 1662case SyntaxKind.EnumDeclaration: 1663case SyntaxKind.RecordDeclaration: 1664case SyntaxKind.RecordStructDeclaration: 1667case SyntaxKind.VariableDeclarator: 1670case SyntaxKind.EnumMemberDeclaration: 1673case SyntaxKind.DestructorDeclaration: 1676case SyntaxKind.ConstructorDeclaration: 1677if (((ConstructorDeclarationSyntax)declaration).Modifiers.Any(SyntaxKind.StaticKeyword)) 1686case SyntaxKind.OperatorDeclaration: 1692case SyntaxKind.ConversionOperatorDeclaration: 1698case SyntaxKind.EventFieldDeclaration: 1699case SyntaxKind.FieldDeclaration: 1702case SyntaxKind.IncompleteMember: 1730case SyntaxKind.GenericName: 1731case SyntaxKind.IdentifierName: 1734case SyntaxKind.QualifiedName: 1740case SyntaxKind.AliasQualifiedName: 2296if (memberDeclaration.Parent.Kind() == SyntaxKind.CompilationUnit) 2299if (memberDeclaration.Kind() is SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration) 2330if (memberDeclaration.Kind() is SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration 2411return (node) => node.Kind() != SyntaxKind.GlobalStatement || node.Parent != unit; 2416return (node) => node.Parent != unit || node.Kind() == SyntaxKind.GlobalStatement; 2429if (typeDeclaration.Kind() is (SyntaxKind.RecordDeclaration or SyntaxKind.ClassDeclaration)) 2458!(node.Kind() == SyntaxKind.ArgumentList && node == typeDeclaration.PrimaryConstructorBaseTypeIfClass?.ArgumentList);

22while (expression.Kind() == SyntaxKind.ParenthesizedExpression)

267if (trivia.Kind() is SyntaxKind.SingleLineDocumentationCommentTrivia or SyntaxKind.MultiLineDocumentationCommentTrivia)

83if (!startLessThanToken.LeadingTrivia.Any(SyntaxKind.DocumentationCommentExteriorTrivia)) 103if (endGreaterThanToken.GetNextToken() is SyntaxToken newLineToken && newLineToken.IsKind(SyntaxKind.XmlTextLiteralNewLineToken)) 141SyntaxKind nodeKind = node.Kind(); 144if (nodeKind == SyntaxKind.XmlCrefAttribute) 176else if (diagnose && nodeKind == SyntaxKind.XmlNameAttribute) 194if (nodeKind == SyntaxKind.XmlEmptyElement) 198else if (nodeKind == SyntaxKind.XmlElementStartTag)

527Debug.Assert(syntax.Kind() == SyntaxKind.Block || syntax.Kind() == SyntaxKind.ArrowExpressionClause); 547if (syntax.Kind() == SyntaxKind.Block)

2082case GotoStatementSyntax { RawKind: (int)SyntaxKind.GotoStatement }: 2090!(expression.Parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression && 2122assignment.Parent?.Kind() is SyntaxKind.ObjectInitializerExpression or SyntaxKind.WithInitializerExpression) 2130!(id.Parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression && 2176if (parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression && isExpression.Right == child)

77case SyntaxKind.NamespaceDeclaration: 78case SyntaxKind.FileScopedNamespaceDeclaration: 91while (name.Kind() == SyntaxKind.QualifiedName) 101case SyntaxKind.ClassDeclaration: 102case SyntaxKind.StructDeclaration: 103case SyntaxKind.RecordDeclaration: 104case SyntaxKind.RecordStructDeclaration: 122goto case SyntaxKind.InterfaceDeclaration; 124case SyntaxKind.InterfaceDeclaration: 137case SyntaxKind.EnumDeclaration: 150case SyntaxKind.EnumMemberDeclaration: 159case SyntaxKind.DelegateDeclaration: 169case SyntaxKind.EventDeclaration: 184case SyntaxKind.EventFieldDeclaration: 185case SyntaxKind.FieldDeclaration: 198case SyntaxKind.ArrowExpressionClause: 209case SyntaxKind.PropertyDeclaration: 231case SyntaxKind.IndexerDeclaration: 255case SyntaxKind.AddAccessorDeclaration: 256case SyntaxKind.RemoveAccessorDeclaration: 257case SyntaxKind.GetAccessorDeclaration: 258case SyntaxKind.SetAccessorDeclaration: 259case SyntaxKind.InitAccessorDeclaration: 272case SyntaxKind.ConstructorDeclaration: 273case SyntaxKind.ConversionOperatorDeclaration: 274case SyntaxKind.DestructorDeclaration: 275case SyntaxKind.MethodDeclaration: 276case SyntaxKind.OperatorDeclaration: 304case SyntaxKind.CompilationUnit: 385case SyntaxKind.ArrowExpressionClause: 388case SyntaxKind.MethodDeclaration: 391case SyntaxKind.OperatorDeclaration: 394case SyntaxKind.ConversionOperatorDeclaration: 397case SyntaxKind.PropertyDeclaration: 400case SyntaxKind.IndexerDeclaration: 403case SyntaxKind.ConstructorDeclaration: 406case SyntaxKind.DestructorDeclaration:

25public static bool IsKind(this SyntaxToken token, SyntaxKind kind) 36public static bool IsKind(this SyntaxTrivia trivia, SyntaxKind kind) 47public static bool IsKind([NotNullWhen(true)] this SyntaxNode? node, SyntaxKind kind) 58public static bool IsKind(this SyntaxNodeOrToken nodeOrToken, SyntaxKind kind) 64public static bool ContainsDirective(this SyntaxNode node, SyntaxKind kind) 67internal static SyntaxKind ContextualKind(this SyntaxToken token) 69return (object)token.Language == (object)LanguageNames.CSharp ? (SyntaxKind)token.RawContextualKind : SyntaxKind.None; 74return identifier.ContextualKind() == SyntaxKind.UnderscoreToken; 81/// <param name="kind">The <see cref="SyntaxKind"/> to find.</param> 83public static int IndexOf<TNode>(this SyntaxList<TNode> list, SyntaxKind kind) 92public static bool Any<TNode>(this SyntaxList<TNode> list, SyntaxKind kind) 102/// <param name="kind">The <see cref="SyntaxKind"/> to find.</param> 104public static int IndexOf<TNode>(this SeparatedSyntaxList<TNode> list, SyntaxKind kind) 113public static bool Any<TNode>(this SeparatedSyntaxList<TNode> list, SyntaxKind kind) 123/// <param name="kind">The <see cref="SyntaxKind"/> to find.</param> 125public static int IndexOf(this SyntaxTriviaList list, SyntaxKind kind) 133public static bool Any(this SyntaxTriviaList list, SyntaxKind kind) 142/// <param name="kind">The <see cref="SyntaxKind"/> to find.</param> 144public static int IndexOf(this SyntaxTokenList list, SyntaxKind kind) 153/// <param name="kind">The <see cref="CSharp.SyntaxKind"/> to test for.</param> 155public static bool Any(this SyntaxTokenList list, SyntaxKind kind) 160internal static SyntaxToken FirstOrDefault(this SyntaxTokenList list, SyntaxKind kind) 173/// Determines if the given raw kind value belongs to the C# <see cref="SyntaxKind"/> enumeration. 179const int FirstVisualBasicKind = (int)SyntaxKind.List + 1; 180const int FirstCSharpKind = (int)SyntaxKind.TildeToken; 187/// Returns <see cref="SyntaxKind"/> for <see cref="SyntaxToken"/> from <see cref="SyntaxToken.RawKind"/> property. 189public static SyntaxKind Kind(this SyntaxToken token) 192return IsCSharpKind(rawKind) ? (SyntaxKind)rawKind : SyntaxKind.None; 196/// Returns <see cref="SyntaxKind"/> for <see cref="SyntaxTrivia"/> from <see cref="SyntaxTrivia.RawKind"/> property. 198public static SyntaxKind Kind(this SyntaxTrivia trivia) 201return IsCSharpKind(rawKind) ? (SyntaxKind)rawKind : SyntaxKind.None; 205/// Returns <see cref="SyntaxKind"/> for <see cref="SyntaxNode"/> from <see cref="SyntaxNode.RawKind"/> property. 207public static SyntaxKind Kind(this SyntaxNode node) 210return IsCSharpKind(rawKind) ? (SyntaxKind)rawKind : SyntaxKind.None; 214/// Returns <see cref="SyntaxKind"/> for <see cref="SyntaxNode"/> from <see cref="SyntaxNodeOrToken.RawKind"/> property. 216public static SyntaxKind Kind(this SyntaxNodeOrToken nodeOrToken) 219return IsCSharpKind(rawKind) ? (SyntaxKind)rawKind : SyntaxKind.None; 239return token.Kind() is (SyntaxKind.StringLiteralToken or SyntaxKind.Utf8StringLiteralToken) && token.Text.Length > 0 && token.Text[0] == '@'; 244return token.IsKind(SyntaxKind.IdentifierToken) && token.Text.Length > 0 && token.Text[0] == '@'; 251case SyntaxKind.OutKeyword: return VarianceKind.Out; 252case SyntaxKind.InKeyword: return VarianceKind.In;

31internal static DeclarationKind ToDeclarationKind(this SyntaxKind kind) 35case SyntaxKind.ClassDeclaration: return DeclarationKind.Class; 36case SyntaxKind.InterfaceDeclaration: return DeclarationKind.Interface; 37case SyntaxKind.StructDeclaration: return DeclarationKind.Struct; 38case SyntaxKind.NamespaceDeclaration: 39case SyntaxKind.FileScopedNamespaceDeclaration: 41case SyntaxKind.EnumDeclaration: return DeclarationKind.Enum; 42case SyntaxKind.DelegateDeclaration: return DeclarationKind.Delegate; 43case SyntaxKind.RecordDeclaration: return DeclarationKind.Record; 44case SyntaxKind.RecordStructDeclaration: return DeclarationKind.RecordStruct;

54node.Kind() is SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration || 55(node.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind == SourceCodeKind.Regular)); 65bool acceptSimpleProgram = node.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind == SourceCodeKind.Regular; 80else if (acceptSimpleProgram && member.IsKind(SyntaxKind.GlobalStatement)) 86if (!topLevelStatement.IsKind(SyntaxKind.EmptyStatement)) 106else if (!hasGlobalMembers && member.Kind() != SyntaxKind.IncompleteMember) 242Debug.Assert(parent.Kind() == SyntaxKind.CompilationUnit && _syntaxTree.Options.Kind != SourceCodeKind.Regular); 289var isGlobal = directive.GlobalKeyword.Kind() != SyntaxKind.None; 358if (directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword)) 517if (directive.GlobalKeyword.IsKind(SyntaxKind.GlobalKeyword)) 544case SyntaxKind.GenericName: 546case SyntaxKind.AliasQualifiedName: 548case SyntaxKind.QualifiedName: 560case SyntaxKind.GenericName: 562case SyntaxKind.AliasQualifiedName: 564case SyntaxKind.QualifiedName: 591SyntaxKind.RecordDeclaration => DeclarationKind.Record, 592SyntaxKind.RecordStructDeclaration => DeclarationKind.RecordStruct, 632if (record.ClassOrStructKeyword.Kind() != SyntaxKind.None) 637else if (node.Kind() is SyntaxKind.ClassDeclaration or SyntaxKind.StructDeclaration or SyntaxKind.InterfaceDeclaration) 641if (node.Kind() is SyntaxKind.InterfaceDeclaration) 661if (modifier.IsKind(SyntaxKind.StaticKeyword) && kind == DeclarationKind.Class) 665else if (modifier.IsKind(SyntaxKind.ReadOnlyKeyword) && kind is DeclarationKind.Struct or DeclarationKind.RecordStruct) 669else if (modifier.IsKind(SyntaxKind.RefKeyword) && kind is DeclarationKind.Struct or DeclarationKind.RecordStruct) 897return modifiers.Any((int)SyntaxKind.RequiredKeyword); 903if (member.Kind == SyntaxKind.MethodDeclaration) 917if (modifier.Kind == SyntaxKind.ThisKeyword) 932case SyntaxKind.CompilationUnit: 935case SyntaxKind.ClassDeclaration: 936case SyntaxKind.StructDeclaration: 937case SyntaxKind.InterfaceDeclaration: 938case SyntaxKind.EnumDeclaration: 939case SyntaxKind.RecordDeclaration: 940case SyntaxKind.RecordStructDeclaration: 943case SyntaxKind.DelegateDeclaration: 946case SyntaxKind.FieldDeclaration: 947case SyntaxKind.EventFieldDeclaration: 950case SyntaxKind.MethodDeclaration: 951case SyntaxKind.OperatorDeclaration: 952case SyntaxKind.ConversionOperatorDeclaration: 953case SyntaxKind.ConstructorDeclaration: 954case SyntaxKind.DestructorDeclaration: 957case SyntaxKind.PropertyDeclaration: 958case SyntaxKind.EventDeclaration: 959case SyntaxKind.IndexerDeclaration: 982case SyntaxKind.FieldDeclaration: 993case SyntaxKind.EventFieldDeclaration: 1004case SyntaxKind.MethodDeclaration: 1017case SyntaxKind.PropertyDeclaration: 1027case SyntaxKind.EventDeclaration: 1037case SyntaxKind.ConstructorDeclaration: 1039set.TryAdd(((Syntax.InternalSyntax.ConstructorDeclarationSyntax)member).Modifiers.Any((int)SyntaxKind.StaticKeyword) 1044case SyntaxKind.DestructorDeclaration: 1049case SyntaxKind.IndexerDeclaration: 1054case SyntaxKind.OperatorDeclaration: 1069case SyntaxKind.ConversionOperatorDeclaration: 1084case SyntaxKind.GlobalStatement:

76case SyntaxKind.ClassDeclaration: 77case SyntaxKind.StructDeclaration: 78case SyntaxKind.InterfaceDeclaration: 79case SyntaxKind.RecordDeclaration: 80case SyntaxKind.RecordStructDeclaration: 84case SyntaxKind.DelegateDeclaration: 88case SyntaxKind.EnumDeclaration:

42if (syntaxNode.Kind() == SyntaxKind.VariableDeclarator) 47SyntaxKind kind = curr.Kind(); 48if (kind == SyntaxKind.FieldDeclaration || kind == SyntaxKind.EventFieldDeclaration) 68case SyntaxKind.SingleLineDocumentationCommentTrivia: 69case SyntaxKind.MultiLineDocumentationCommentTrivia: 95case SyntaxKind.WhitespaceTrivia: 96case SyntaxKind.EndOfLineTrivia:

110if (label.Kind() == SyntaxKind.CasePatternSwitchLabel)

131return ExitPoints.WhereAsArray(s => s.IsKind(SyntaxKind.ReturnStatement) || s.IsKind(SyntaxKind.YieldBreakStatement));

175syntax.IsKind(SyntaxKind.Block) || 176syntax.IsKind(SyntaxKind.ArrowExpressionClause) || 177syntax.IsKind(SyntaxKind.ConstructorDeclaration) || 178syntax.IsKind(SyntaxKind.CompilationUnit));

945if (initializerKind == (int)SyntaxKind.ThisConstructorInitializer) 951else if (initializerKind == (int)SyntaxKind.BaseConstructorInitializer) 6083if (syntax.Kind() != SyntaxKind.InvocationExpression) 6100return nameSyntax.Kind() != SyntaxKind.GenericName;

54if (node.Parent.Kind() == SyntaxKind.AddressOfExpression)

517Debug.Assert(node.Syntax.IsKind(SyntaxKind.CatchClause)); 1031Debug.Assert(pendingCatch.SyntaxOpt.IsKind(SyntaxKind.TryStatement));

368Debug.Assert(node.Syntax.IsKind(SyntaxKind.AwaitExpression) || node.WasCompilerGenerated);

1744case SyntaxKind.ForStatement: 1745case SyntaxKind.ForEachStatement: 1746case SyntaxKind.ForEachVariableStatement: 1747case SyntaxKind.WhileStatement: 1748case SyntaxKind.DoStatement: 1749case SyntaxKind.SimpleLambdaExpression: 1750case SyntaxKind.ParenthesizedLambdaExpression:

81(local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection || 82local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchExpressionArm))

550case SyntaxKind.ParenthesizedLambdaExpression: 553if (lambdaSyntax.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword) 557else if (lambdaSyntax.Body.Kind() == SyntaxKind.Block) 561else if (lambdaSyntax.Body.Kind() == SyntaxKind.RefExpression) 568case SyntaxKind.SimpleLambdaExpression: 571if (lambdaSyntax.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword) 575else if (lambdaSyntax.Body.Kind() == SyntaxKind.Block) 579else if (lambdaSyntax.Body.Kind() == SyntaxKind.RefExpression) 586case SyntaxKind.AnonymousMethodExpression:

38if (local.Syntax.Kind() == SyntaxKind.DeclarationExpression)

419SyntaxKind parentKind = returnStatement.ExpressionOpt.Syntax.Parent.Kind(); 422case SyntaxKind.ParenthesizedLambdaExpression: 423case SyntaxKind.SimpleLambdaExpression: 424case SyntaxKind.ArrowExpressionClause: 460if (!original.IsConstructorInitializer() || original.Syntax.Kind() != SyntaxKind.ConstructorDeclaration) 577case SyntaxKind.MethodDeclaration: 578case SyntaxKind.PropertyDeclaration: 579case SyntaxKind.GetAccessorDeclaration: 580case SyntaxKind.SetAccessorDeclaration: 581case SyntaxKind.InitAccessorDeclaration: 582case SyntaxKind.ConstructorDeclaration: 583case SyntaxKind.OperatorDeclaration: 597case SyntaxKind.MethodDeclaration: 601case SyntaxKind.PropertyDeclaration: 605case SyntaxKind.GetAccessorDeclaration: 606case SyntaxKind.SetAccessorDeclaration: 607case SyntaxKind.InitAccessorDeclaration: 611case SyntaxKind.ConstructorDeclaration: 615case SyntaxKind.OperatorDeclaration:

63case SyntaxKind.ConstructorDeclaration: 67case SyntaxKind.BaseConstructorInitializer: 68case SyntaxKind.ThisConstructorInitializer: 94if (syntax.IsKind(SyntaxKind.Parameter)) 104case SyntaxKind.VariableDeclarator: 108case SyntaxKind.PropertyDeclaration: 131if (original.WasCompilerGenerated && original.Syntax.Kind() == SyntaxKind.Block) 271case SyntaxKind.ForEachStatement: 277case SyntaxKind.ForEachVariableStatement: 343return AddSequencePoint(original.Syntax.Kind() == SyntaxKind.VariableDeclarator ? 361if (original.WasCompilerGenerated && original.ExpressionOpt == null && original.Syntax.Kind() == SyntaxKind.Block)

58if (constructorSyntax.Modifiers.Any(SyntaxKind.StaticKeyword)) 116case SyntaxKind.EventFieldDeclaration: 117case SyntaxKind.FieldDeclaration: 124case SyntaxKind.LocalDeclarationStatement: 128Debug.Assert(!modifiers.Any(SyntaxKind.ConstKeyword)); // const locals don't have a sequence point 138case SyntaxKind.UsingStatement: 139case SyntaxKind.FixedStatement: 140case SyntaxKind.ForStatement:

49Debug.Assert(!original.WasCompilerGenerated || original.Syntax.Kind() == SyntaxKind.Block); 114Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 122Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 130Debug.Assert(original.Syntax.Kind() == SyntaxKind.DoStatement); 137Debug.Assert(original.Syntax.Kind() == SyntaxKind.WhileStatement); 158Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachStatement); 165Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForEachVariableStatement); 179Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 186Debug.Assert(original.Syntax.Kind() == SyntaxKind.ForStatement); 193Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 200Debug.Assert(original.Syntax.Kind() == SyntaxKind.IfStatement); 207Debug.Assert(original.Syntax.Kind() == SyntaxKind.LabeledStatement); 213Debug.Assert(original.Syntax.Kind() == SyntaxKind.VariableDeclarator || 214(original.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement && 244Debug.Assert(original.Syntax.Kind() == SyntaxKind.LockStatement); 255Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement); 274Debug.Assert(original.Syntax.Kind() == SyntaxKind.UsingStatement); 287Debug.Assert(original.Syntax.Kind() == SyntaxKind.CatchClause); 294Debug.Assert(original.Syntax.Kind() == SyntaxKind.SwitchStatement);

742if (syntax.IsKind(SyntaxKind.Parameter)) 748if (syntax is ExpressionSyntax { Parent: { } parent } && parent.Kind() == SyntaxKind.EqualsValueClause) // Should be the initial value. 753case SyntaxKind.VariableDeclarator: 754case SyntaxKind.PropertyDeclaration:

554loweredInput.Syntax.Kind() == SyntaxKind.TupleExpression &&

89case SyntaxKind.TryStatement: 93case SyntaxKind.UsingStatement: 120case SyntaxKind.ForEachStatement: 121case SyntaxKind.ForEachVariableStatement: 127case SyntaxKind.SimpleLambdaExpression: 128case SyntaxKind.ParenthesizedLambdaExpression: 129case SyntaxKind.AnonymousMethodExpression: 132case SyntaxKind.CatchClause: 140goto case SyntaxKind.FinallyClause; 141case SyntaxKind.FinallyClause: 144Debug.Assert(node is { } && node.Kind() == SyntaxKind.TryStatement);

77(originalOpt.Syntax.Kind() == SyntaxKind.VariableDeclarator || 78(originalOpt.Syntax.Kind() == SyntaxKind.LocalDeclarationStatement &&

50if (section?.Kind() == SyntaxKind.SwitchSection)

29(node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false))))

50SyntaxToken awaitKeyword = node.Syntax.Kind() == SyntaxKind.UsingStatement ? ((UsingStatementSyntax)node.Syntax).AwaitKeyword : default;

21(!node.WasCompilerGenerated || (node.Syntax.Kind() == SyntaxKind.Block && _factory.CurrentFunction?.IsAsync == false)))

325if ((local.SynthesizedKind == SynthesizedLocalKind.UserDefined && local.ScopeDesignatorOpt?.Kind() != SyntaxKind.SwitchSection) || 507Debug.Assert(awaitSyntaxOpt.IsKind(SyntaxKind.AwaitExpression) || awaitSyntaxOpt.IsKind(SyntaxKind.SwitchExpression)); 721(local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchSection || 722local.ScopeDesignatorOpt?.Kind() == SyntaxKind.SwitchExpressionArm));

1991var kind = node.Kind(); 1997case SyntaxKind.LocalDeclarationStatement: 2008case SyntaxKind.VariableDeclarator: 2045SyntaxNode declarationSyntax = declarationGroupSyntax.IsKind(SyntaxKind.LocalDeclarationStatement) ? 2606if (boundSwitchLabel.Syntax.Kind() == SyntaxKind.DefaultSwitchLabel) 2638if (boundQueryClause.Syntax.Kind() != SyntaxKind.QueryExpression)

137Debug.Assert(token.Kind() != SyntaxKind.None, "how could we not get a real token back?"); 170if (parent.Kind() == SyntaxKind.InterpolatedStringExpression)

48this.CurrentNodeOrToken.Kind() == SyntaxKind.None || 49this.CurrentNodeOrToken.Kind() == SyntaxKind.EndOfFileToken; 55return token.Kind() == SyntaxKind.EndOfFileToken || token.FullWidth != 0; 126if (node.Kind() == SyntaxKind.InterpolatedStringExpression) 162for (var node = cursor.CurrentNodeOrToken; node.Kind() != SyntaxKind.None && !SyntaxFacts.IsAnyToken(node.Kind()); node = cursor.CurrentNodeOrToken)

302internal static bool IsFabricatedToken(SyntaxKind kind) 306case SyntaxKind.GreaterThanGreaterThanToken: 307case SyntaxKind.GreaterThanGreaterThanEqualsToken: 308case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: 309case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:

35var hash = this.EatToken(SyntaxKind.HashToken, false); 52SyntaxKind contextualKind = this.CurrentToken.ContextualKind; 55case SyntaxKind.IfKeyword: 59case SyntaxKind.ElifKeyword: 63case SyntaxKind.ElseKeyword: 67case SyntaxKind.EndIfKeyword: 71case SyntaxKind.RegionKeyword: 75case SyntaxKind.EndRegionKeyword: 79case SyntaxKind.DefineKeyword: 80case SyntaxKind.UndefKeyword: 84case SyntaxKind.ErrorKeyword: 85case SyntaxKind.WarningKeyword: 89case SyntaxKind.LineKeyword: 91result = (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) ? 96case SyntaxKind.PragmaKeyword: 100case SyntaxKind.ReferenceKeyword: 104case SyntaxKind.LoadKeyword: 108case SyntaxKind.NullableKeyword: 113if (lexer.Options.Kind == SourceCodeKind.Script && contextualKind == SyntaxKind.ExclamationToken && hashPosition == 0 && !hash.HasTrailingTrivia) 115result = this.ParseShebangDirective(hash, this.EatToken(SyntaxKind.ExclamationToken), isActive); 119var id = this.EatToken(SyntaxKind.IdentifierToken, false); 249var name = this.EatToken(SyntaxKind.IdentifierToken, ErrorCode.ERR_IdentifierExpected); 252if (keyword.Kind == SyntaxKind.DefineKeyword) 287bool isError = keyword.Kind == SyntaxKind.ErrorKeyword; 301if (t.Kind == SyntaxKind.WhitespaceTrivia) 373case SyntaxKind.DefaultKeyword: 374case SyntaxKind.HiddenKeyword: 378line = this.EatToken(SyntaxKind.NumericLiteralToken, ErrorCode.ERR_InvalidLineNumber, reportError: isActive); 380if (isActive && !line.IsMissing && line.Kind == SyntaxKind.NumericLiteralToken) 392if (this.CurrentToken.Kind == SyntaxKind.StringLiteralToken && 408Debug.Assert(CurrentToken.Kind == SyntaxKind.OpenParenToken); 417var minus = EatToken(SyntaxKind.MinusToken, reportError: reportError); 427var characterOffset = (CurrentToken.Kind == SyntaxKind.NumericLiteralToken) ? 436var file = EatToken(SyntaxKind.StringLiteralToken, ErrorCode.ERR_MissingPPFile, reportError: reportError); 457var openParen = EatToken(SyntaxKind.OpenParenToken, reportError); 462var comma = EatToken(SyntaxKind.CommaToken, reportError); 467var closeParen = EatToken(SyntaxKind.CloseParenToken, reportError); 475var token = this.EatToken(SyntaxKind.NumericLiteralToken, ErrorCode.ERR_LineSpanDirectiveInvalidValue, reportError: reportError); 481else if (token.Kind == SyntaxKind.NumericLiteralToken) 507SyntaxToken file = this.EatToken(SyntaxKind.StringLiteralToken, ErrorCode.ERR_ExpectedPPFile, reportError: isActive); 527SyntaxToken file = this.EatToken(SyntaxKind.StringLiteralToken, ErrorCode.ERR_ExpectedPPFile, reportError: isActive); 542SyntaxKind.EnableKeyword => EatToken(), 543SyntaxKind.DisableKeyword => EatToken(), 544SyntaxKind.RestoreKeyword => EatToken(), 545_ => EatToken(SyntaxKind.DisableKeyword, ErrorCode.ERR_NullableDirectiveQualifierExpected, reportError: isActive) 550SyntaxKind.WarningsKeyword => EatToken(), 551SyntaxKind.AnnotationsKeyword => EatToken(), 552SyntaxKind.EndOfDirectiveToken => null, 553SyntaxKind.EndOfFileToken => null, 554_ => EatToken(SyntaxKind.WarningsKeyword, ErrorCode.ERR_NullableDirectiveTargetExpected, reportError: !setting.IsMissing && isActive) 569if (this.CurrentToken.ContextualKind == SyntaxKind.WarningKeyword) 571var warning = this.EatContextualToken(SyntaxKind.WarningKeyword); 573if (this.CurrentToken.Kind == SyntaxKind.DisableKeyword || this.CurrentToken.Kind == SyntaxKind.RestoreKeyword) 578while (this.CurrentToken.Kind != SyntaxKind.EndOfDirectiveToken) 583if (this.CurrentToken.Kind == SyntaxKind.NumericLiteralToken) 593idExpression = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, id); 595else if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 609id = this.EatToken(SyntaxKind.NumericLiteralToken, ErrorCode.WRN_IdentifierOrNumericLiteralExpected, reportError: isActive); 610idExpression = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, id); 616if (this.CurrentToken.Kind != SyntaxKind.CommaToken) 629style = this.EatToken(SyntaxKind.DisableKeyword, ErrorCode.WRN_IllegalPPWarning, reportError: isActive); 634else if (this.CurrentToken.Kind == SyntaxKind.ChecksumKeyword) 637var file = this.EatToken(SyntaxKind.StringLiteralToken, ErrorCode.WRN_IllegalPPChecksum, reportError: isActive); 638var guid = this.EatToken(SyntaxKind.StringLiteralToken, ErrorCode.WRN_IllegalPPChecksum, reportError: isActive && !file.IsMissing); 648var bytes = this.EatToken(SyntaxKind.StringLiteralToken, ErrorCode.WRN_IllegalPPChecksum, reportError: isActive && !guid.IsMissing); 674var warning = this.EatToken(SyntaxKind.WarningKeyword, ErrorCode.WRN_IllegalPragma, reportError: isActive); 675var style = this.EatToken(SyntaxKind.DisableKeyword, reportError: false); 697if (this.CurrentToken.Kind != SyntaxKind.EndOfDirectiveToken && 698this.CurrentToken.Kind != SyntaxKind.EndOfFileToken) 717while (this.CurrentToken.Kind != SyntaxKind.EndOfDirectiveToken && 718this.CurrentToken.Kind != SyntaxKind.EndOfFileToken) 725SyntaxToken endOfDirective = this.CurrentToken.Kind == SyntaxKind.EndOfDirectiveToken 727: SyntaxFactory.Token(SyntaxKind.EndOfDirectiveToken); 746while (this.CurrentToken.Kind == SyntaxKind.BarBarToken) 750left = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, left, op, right); 759while (this.CurrentToken.Kind == SyntaxKind.AmpersandAmpersandToken) 763left = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalAndExpression, left, op, right); 772while (this.CurrentToken.Kind == SyntaxKind.EqualsEqualsToken || this.CurrentToken.Kind == SyntaxKind.ExclamationEqualsToken) 784if (this.CurrentToken.Kind == SyntaxKind.ExclamationToken) 787return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, op, this.ParseLogicalNot()); 795var k = this.CurrentToken.Kind; 798case SyntaxKind.OpenParenToken: 801var close = this.EatToken(SyntaxKind.CloseParenToken); 803case SyntaxKind.IdentifierToken: 806case SyntaxKind.TrueKeyword: 807case SyntaxKind.FalseKeyword: 810return SyntaxFactory.IdentifierName(this.EatToken(SyntaxKind.IdentifierToken, ErrorCode.ERR_InvalidPreprocExpr)); 826identifier = SyntaxFactory.Identifier(SyntaxKind.IdentifierToken, leading, text, identifierPart, trailing); 846case SyntaxKind.ParenthesizedExpression: 848case SyntaxKind.TrueLiteralExpression: 849case SyntaxKind.FalseLiteralExpression: 851case SyntaxKind.LogicalAndExpression: 852case SyntaxKind.BitwiseAndExpression: 854case SyntaxKind.LogicalOrExpression: 855case SyntaxKind.BitwiseOrExpression: 857case SyntaxKind.EqualsExpression: 859case SyntaxKind.NotEqualsExpression: 861case SyntaxKind.LogicalNotExpression: 863case SyntaxKind.IdentifierName:

26public SyntaxKind Kind 57case SyntaxKind.DefineDirectiveTrivia: 58case SyntaxKind.UndefDirectiveTrivia: 60case SyntaxKind.IfDirectiveTrivia: 61case SyntaxKind.ElifDirectiveTrivia: 62case SyntaxKind.ElseDirectiveTrivia: 81case SyntaxKind.DefineDirectiveTrivia: 83case SyntaxKind.UndefDirectiveTrivia: 154case SyntaxKind.DefineDirectiveTrivia: 161case SyntaxKind.UndefDirectiveTrivia: 169case SyntaxKind.ElifDirectiveTrivia: 170case SyntaxKind.ElseDirectiveTrivia: 181while (current.Head.Kind != SyntaxKind.IfDirectiveTrivia); 199else if (current.Head.Kind == SyntaxKind.IfDirectiveTrivia) 211return prev != null && prev.Any() && prev.Head.Kind != SyntaxKind.RegionDirectiveTrivia; 217return prev != null && prev.Any() && (prev.Head.Kind == SyntaxKind.IfDirectiveTrivia || prev.Head.Kind == SyntaxKind.ElifDirectiveTrivia); 223return prev != null && prev.Any() && prev.Head.Kind == SyntaxKind.RegionDirectiveTrivia; 230case SyntaxKind.EndIfDirectiveTrivia: 239case SyntaxKind.EndRegionDirectiveTrivia: 266if (stack.Head.Kind == SyntaxKind.IfDirectiveTrivia) 275case SyntaxKind.ElifDirectiveTrivia: 276case SyntaxKind.ElseDirectiveTrivia: 300if (stack.Head.Kind == SyntaxKind.RegionDirectiveTrivia) 317case SyntaxKind.IfDirectiveTrivia: 334case SyntaxKind.IfDirectiveTrivia: 335case SyntaxKind.ElifDirectiveTrivia: 336case SyntaxKind.ElseDirectiveTrivia: 337case SyntaxKind.RegionDirectiveTrivia: 350while (current != null && current.Any() && current.Head.Kind != SyntaxKind.RegionDirectiveTrivia) 412case SyntaxKind.IfDirectiveTrivia: 413case SyntaxKind.ElifDirectiveTrivia: 414case SyntaxKind.ElseDirectiveTrivia: 415case SyntaxKind.EndIfDirectiveTrivia: 416case SyntaxKind.DefineDirectiveTrivia: 417case SyntaxKind.UndefDirectiveTrivia: 418case SyntaxKind.RegionDirectiveTrivia: 419case SyntaxKind.EndRegionDirectiveTrivia:

82if (this.CurrentToken.Kind != SyntaxKind.EndOfDocumentationCommentToken) 87var eoc = this.EatToken(SyntaxKind.EndOfDocumentationCommentToken); 90SyntaxKind kind = _isDelimited ? SyntaxKind.MultiLineDocumentationCommentTrivia : SyntaxKind.SingleLineDocumentationCommentTrivia; 102bool endTag = this.CurrentToken.Kind == SyntaxKind.LessThanSlashToken; 109while (this.CurrentToken.Kind != SyntaxKind.EndOfDocumentationCommentToken) 150case SyntaxKind.XmlTextLiteralToken: 151case SyntaxKind.XmlTextLiteralNewLineToken: 152case SyntaxKind.XmlEntityLiteralToken: 154case SyntaxKind.LessThanToken: 156case SyntaxKind.XmlCommentStartToken: 158case SyntaxKind.XmlCDataStartToken: 160case SyntaxKind.XmlProcessingInstructionStartToken: 162case SyntaxKind.EndOfDocumentationCommentToken: 174case SyntaxKind.LessThanToken: 175case SyntaxKind.LessThanSlashToken: 176case SyntaxKind.XmlCommentStartToken: 177case SyntaxKind.XmlCDataStartToken: 178case SyntaxKind.XmlProcessingInstructionStartToken: 179case SyntaxKind.GreaterThanToken: 180case SyntaxKind.SlashGreaterThanToken: 181case SyntaxKind.EndOfDocumentationCommentToken: 191while (this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralToken 192|| this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralNewLineToken 193|| this.CurrentToken.Kind == SyntaxKind.XmlEntityLiteralToken) 205var lessThan = this.EatToken(SyntaxKind.LessThanToken); // guaranteed 219if (this.CurrentToken.Kind == SyntaxKind.GreaterThanToken) 232var lessThanSlash = this.EatToken(SyntaxKind.LessThanSlashToken, reportError: false); 240endName = SyntaxFactory.XmlName(prefix: null, localName: SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)); 241greaterThan = SyntaxFactory.MissingToken(SyntaxKind.GreaterThanToken); 259if (this.CurrentToken.Kind != SyntaxKind.GreaterThanToken) 262p => p.CurrentToken.Kind != SyntaxKind.GreaterThanToken, 268greaterThan = this.EatToken(SyntaxKind.GreaterThanToken); 282var slashGreater = this.EatToken(SyntaxKind.SlashGreaterThanToken, false); 329if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 349p => p.CurrentToken.Kind != SyntaxKind.IdentifierName, 352p => p.CurrentToken.Kind == SyntaxKind.GreaterThanToken 353|| p.CurrentToken.Kind == SyntaxKind.SlashGreaterThanToken 354|| p.CurrentToken.Kind == SyntaxKind.LessThanToken 355|| p.CurrentToken.Kind == SyntaxKind.LessThanSlashToken 356|| p.CurrentToken.Kind == SyntaxKind.EndOfDocumentationCommentToken 357|| p.CurrentToken.Kind == SyntaxKind.EndOfFileToken, 452var equals = this.EatToken(SyntaxKind.EqualsToken, false); 459case SyntaxKind.SingleQuoteToken: 460case SyntaxKind.DoubleQuoteToken: 468SyntaxFactory.MissingToken(SyntaxKind.DoubleQuoteToken), 470SyntaxFactory.MissingToken(SyntaxKind.DoubleQuoteToken)); 530SyntaxToken openQuote = EatToken(this.CurrentToken.Kind == SyntaxKind.SingleQuoteToken 531? SyntaxKind.SingleQuoteToken 532: SyntaxKind.DoubleQuoteToken); 538if ((current.Kind == SyntaxKind.XmlTextLiteralToken || current.Kind == SyntaxKind.XmlEntityLiteralToken) && 545if ((current.Kind == SyntaxKind.XmlTextLiteralToken || current.Kind == SyntaxKind.XmlEntityLiteralToken) && 561SyntaxKind quoteKind = startQuote.Kind; 564var saveMode = this.SetMode(quoteKind == SyntaxKind.SingleQuoteToken 579SyntaxKind quoteKind = startQuote.Kind; 582var saveMode = this.SetMode(quoteKind == SyntaxKind.SingleQuoteToken 597SyntaxKind quoteKind = startQuote.Kind; 607var saveMode = this.SetMode(quoteKind == SyntaxKind.SingleQuoteToken 611while (this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralToken 612|| this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralNewLineToken 613|| this.CurrentToken.Kind == SyntaxKind.XmlEntityLiteralToken 614|| this.CurrentToken.Kind == SyntaxKind.LessThanToken) 617if (token.Kind == SyntaxKind.LessThanToken) 641var quoteKind = this.CurrentToken.Kind == SyntaxKind.SingleQuoteToken 642? SyntaxKind.SingleQuoteToken 643: SyntaxKind.DoubleQuoteToken; 653private SyntaxToken ParseXmlAttributeEndQuote(SyntaxKind quoteKind) 670var quote = SyntaxFactory.MissingToken(SyntaxKind.DoubleQuoteToken); 688var id = this.EatToken(SyntaxKind.IdentifierToken); 690if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 706id = this.EatToken(SyntaxKind.IdentifierToken); 727var lessThanExclamationMinusMinusToken = this.EatToken(SyntaxKind.XmlCommentStartToken); 730while (this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralToken 731|| this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralNewLineToken 732|| this.CurrentToken.Kind == SyntaxKind.MinusMinusToken) 735if (token.Kind == SyntaxKind.MinusMinusToken) 747var minusMinusGreaterThanToken = this.EatToken(SyntaxKind.XmlCommentEndToken); 754var startCDataToken = this.EatToken(SyntaxKind.XmlCDataStartToken); 757while (this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralToken 758|| this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralNewLineToken) 763var endCDataToken = this.EatToken(SyntaxKind.XmlCDataEndToken); 770var startProcessingInstructionToken = this.EatToken(SyntaxKind.XmlProcessingInstructionStartToken); 779while (this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralToken 780|| this.CurrentToken.Kind == SyntaxKind.XmlTextLiteralNewLineToken) 790var endProcessingInstructionToken = this.EatToken(SyntaxKind.XmlProcessingInstructionEndToken); 795protected override SyntaxDiagnosticInfo GetExpectedTokenError(SyntaxKind expected, SyntaxKind actual, int offset, int length) 807case SyntaxKind.IdentifierToken: 815protected override SyntaxDiagnosticInfo GetExpectedTokenError(SyntaxKind expected, SyntaxKind actual) 828case SyntaxKind.IdentifierToken: 905else if (type.Kind != SyntaxKind.QualifiedName && this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 913SyntaxToken dot = EatToken(SyntaxKind.DotToken); 947case SyntaxKind.ThisKeyword: 949case SyntaxKind.OperatorKeyword: 951case SyntaxKind.ExplicitKeyword: 952case SyntaxKind.ImplicitKeyword: 976Debug.Assert(CurrentToken.Kind == SyntaxKind.ThisKeyword); 988Debug.Assert(CurrentToken.Kind == SyntaxKind.OperatorKeyword); 1000operatorToken = SyntaxFactory.MissingToken(SyntaxKind.PlusToken); 1020if (operatorToken.Kind == SyntaxKind.GreaterThanToken && operatorToken.GetTrailingTriviaWidth() == 0 && CurrentToken.GetLeadingTriviaWidth() == 0) 1022if (CurrentToken.Kind == SyntaxKind.GreaterThanToken) 1027CurrentToken.Kind is (SyntaxKind.GreaterThanToken or SyntaxKind.GreaterThanEqualsToken)) 1031if (operatorToken3.Kind == SyntaxKind.GreaterThanToken) 1035SyntaxKind.GreaterThanGreaterThanGreaterThanToken, 1046SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken, 1051operatorToken = SyntaxFactory.MissingToken(SyntaxKind.PlusToken); 1068SyntaxKind.GreaterThanGreaterThanToken, 1074else if (CurrentToken.Kind == SyntaxKind.EqualsToken) 1079SyntaxKind.GreaterThanEqualsToken, 1084else if (CurrentToken.Kind == SyntaxKind.GreaterThanEqualsToken) 1089SyntaxKind.GreaterThanGreaterThanEqualsToken, 1094operatorToken = SyntaxFactory.MissingToken(SyntaxKind.PlusToken); 1129if (CurrentToken.Kind == SyntaxKind.UncheckedKeyword) 1137return TryEatToken(SyntaxKind.CheckedKeyword); 1146Debug.Assert(CurrentToken.Kind == SyntaxKind.ExplicitKeyword || 1147CurrentToken.Kind == SyntaxKind.ImplicitKeyword); 1150SyntaxToken operatorKeyword = EatToken(SyntaxKind.OperatorKeyword); 1181SyntaxKind openKind = useSquareBrackets ? SyntaxKind.OpenBracketToken : SyntaxKind.OpenParenToken; 1182SyntaxKind closeKind = useSquareBrackets ? SyntaxKind.CloseBracketToken : SyntaxKind.CloseParenToken; 1194while (CurrentToken.Kind == SyntaxKind.CommaToken || IsPossibleCrefParameter()) 1200SyntaxToken comma = EatToken(SyntaxKind.CommaToken); 1209Debug.Assert(CurrentToken.Kind != SyntaxKind.CommaToken); 1234SyntaxKind kind = this.CurrentToken.Kind; 1237case SyntaxKind.RefKeyword: 1238case SyntaxKind.OutKeyword: 1239case SyntaxKind.InKeyword: 1240case SyntaxKind.IdentifierToken: 1258case SyntaxKind.RefKeyword: 1259case SyntaxKind.OutKeyword: 1260case SyntaxKind.InKeyword: 1276SyntaxToken identifierToken = EatToken(SyntaxKind.IdentifierToken); 1278if (CurrentToken.Kind != SyntaxKind.LessThanToken) 1292if (typeArgumentsMustBeIdentifiers && typeSyntax.Kind != SyntaxKind.IdentifierName) 1300var currentKind = CurrentToken.Kind; 1301if (currentKind == SyntaxKind.CommaToken || currentKind == SyntaxKind.IdentifierToken || 1306list.AddSeparator(EatToken(SyntaxKind.CommaToken)); 1314SyntaxToken close = EatToken(SyntaxKind.GreaterThanToken); 1371else if (CurrentToken.Kind == SyntaxKind.IdentifierToken && PeekToken(1).Kind == SyntaxKind.ColonColonToken) 1375if (alias.ContextualKind == SyntaxKind.GlobalKeyword) 1391if (checkForMember && (leftName.IsMissing || CurrentToken.Kind != SyntaxKind.DotToken)) 1403while (CurrentToken.Kind == SyntaxKind.DotToken) 1412if (checkForMember && (rightName.IsMissing || CurrentToken.Kind != SyntaxKind.DotToken)) 1434if (CurrentToken.Kind == SyntaxKind.QuestionToken) 1439while (CurrentToken.Kind == SyntaxKind.AsteriskToken) 1444if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) 1446var omittedArraySizeExpressionInstance = SyntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 1450while (CurrentToken.Kind == SyntaxKind.OpenBracketToken) 1456while (this.CurrentToken.Kind != SyntaxKind.CloseBracketToken) 1458if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 1481var close = this.EatToken(SyntaxKind.CloseBracketToken); 1510case SyntaxKind.SingleQuoteToken: 1512case SyntaxKind.DoubleQuoteToken: 1514case SyntaxKind.EndOfFileToken: 1515case SyntaxKind.EndOfDocumentationCommentToken: 1517case SyntaxKind.BadToken: 1520return CurrentToken.Text == SyntaxFacts.GetText(SyntaxKind.LessThanToken) || 1553SyntaxToken identifierToken = this.EatToken(SyntaxKind.IdentifierToken, reportError: false); 1578case SyntaxKind.SingleQuoteToken: 1580case SyntaxKind.DoubleQuoteToken: 1582case SyntaxKind.EndOfFileToken: 1583case SyntaxKind.EndOfDocumentationCommentToken: 1585case SyntaxKind.BadToken: 1588return CurrentToken.Text == SyntaxFacts.GetText(SyntaxKind.LessThanToken) ||

40return SyntaxFactory.Identifier(SyntaxKind.None, null, text, text, trailing: null); 45return SyntaxFactory.Identifier(SyntaxKind.None, SyntaxFactory.Space, text, text, trailing: null);

49private static bool IsSomeWord(SyntaxKind kind) 51return kind == SyntaxKind.IdentifierToken || SyntaxFacts.IsKeywordKind(kind); 94if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken) 175SyntaxFactory.Token(SyntaxKind.EndOfFileToken))); 185this.ParseNamespaceBody(ref tmp, ref body, ref initialBadNodes, SyntaxKind.CompilationUnit); 187var eof = this.EatToken(SyntaxKind.EndOfFileToken); 249Debug.Assert(this.CurrentToken.Kind == SyntaxKind.NamespaceKeyword); 250var namespaceToken = this.EatToken(SyntaxKind.NamespaceKeyword); 262if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 264semicolon = this.EatToken(SyntaxKind.SemicolonToken); 266else if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken || IsPossibleNamespaceMemberDeclaration()) 270openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 276openBrace = this.EatTokenWithPrejudice(SyntaxKind.OpenBraceToken); 277openBrace = this.ConvertToMissingWithTrailingTrivia(openBrace, SyntaxKind.OpenBraceToken); 290this.ParseNamespaceBody(ref semicolon, ref body, ref initialBadNodes, SyntaxKind.FileScopedNamespaceDeclaration); 306this.ParseNamespaceBody(ref openBrace, ref body, ref initialBadNodes, SyntaxKind.NamespaceDeclaration); 318this.EatToken(SyntaxKind.CloseBraceToken), 319this.TryEatToken(SyntaxKind.SemicolonToken)); 329private static bool IsPossibleStartOfTypeDeclaration(SyntaxKind kind) 331return IsTypeModifierOrTypeKeyword(kind) || kind == SyntaxKind.OpenBracketToken; 335private static bool IsTypeModifierOrTypeKeyword(SyntaxKind kind) 339case SyntaxKind.EnumKeyword: 340case SyntaxKind.DelegateKeyword: 341case SyntaxKind.ClassKeyword: 342case SyntaxKind.InterfaceKeyword: 343case SyntaxKind.StructKeyword: 344case SyntaxKind.AbstractKeyword: 345case SyntaxKind.InternalKeyword: 346case SyntaxKind.NewKeyword: 347case SyntaxKind.PrivateKeyword: 348case SyntaxKind.ProtectedKeyword: 349case SyntaxKind.PublicKeyword: 350case SyntaxKind.SealedKeyword: 351case SyntaxKind.StaticKeyword: 352case SyntaxKind.UnsafeKeyword: 412SyntaxKind parentKind) 431case SyntaxKind.NamespaceKeyword: 446case SyntaxKind.CloseBraceToken: 472case SyntaxKind.EndOfFileToken: 476case SyntaxKind.ExternKeyword: 503case SyntaxKind.UsingKeyword: 504if (isGlobal && (this.PeekToken(1).Kind == SyntaxKind.OpenParenToken || (!IsScript && IsPossibleTopLevelUsingLocalDeclarationStatement()))) 517case SyntaxKind.IdentifierToken: 518if (this.CurrentToken.ContextualKind != SyntaxKind.GlobalKeyword || this.PeekToken(1).Kind != SyntaxKind.UsingKeyword) 530case SyntaxKind.OpenBracketToken: 575else if (memberOrStatement.Kind == SyntaxKind.IncompleteMember && seen < NamespaceParts.MembersAndStatements) 605case SyntaxKind.GlobalStatement: 622case SyntaxKind.NamespaceDeclaration: 623case SyntaxKind.FileScopedNamespaceDeclaration: 624case SyntaxKind.EnumDeclaration: 625case SyntaxKind.StructDeclaration: 626case SyntaxKind.ClassDeclaration: 627case SyntaxKind.InterfaceDeclaration: 628case SyntaxKind.DelegateDeclaration: 629case SyntaxKind.RecordDeclaration: 630case SyntaxKind.RecordStructDeclaration: 697case SyntaxKind.ExternKeyword: 698case SyntaxKind.UsingKeyword: 699case SyntaxKind.NamespaceKeyword: 701case SyntaxKind.IdentifierToken: 710if (this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword) 716else if (this.PeekToken(1).Kind == SyntaxKind.NamespaceKeyword) 727return this.CurrentToken.Kind == SyntaxKind.CloseBraceToken; 752return this.CurrentToken.Kind == SyntaxKind.ExternKeyword 753&& this.PeekToken(1) is { Kind: SyntaxKind.IdentifierToken, ContextualKind: SyntaxKind.AliasKeyword } 754&& this.PeekToken(2).Kind == SyntaxKind.IdentifierToken 755&& this.PeekToken(3).Kind == SyntaxKind.SemicolonToken; 760if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.ExternAliasDirective) 765Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ExternKeyword); 768this.EatToken(SyntaxKind.ExternKeyword), 769this.EatContextualToken(SyntaxKind.AliasKeyword), 771this.EatToken(SyntaxKind.SemicolonToken)); 779this.EatToken(SyntaxKind.EqualsToken)); 784if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.UsingDirective) 789var globalToken = this.CurrentToken.ContextualKind == SyntaxKind.GlobalKeyword 793Debug.Assert(this.CurrentToken.Kind == SyntaxKind.UsingKeyword); 795var usingToken = this.EatToken(SyntaxKind.UsingKeyword); 796var staticToken = this.TryEatToken(SyntaxKind.StaticKeyword); 797var unsafeToken = this.TryEatToken(SyntaxKind.UnsafeKeyword); 804var isAliasToFunctionPointer = alias != null && this.CurrentToken.Kind == SyntaxKind.DelegateKeyword; 823type = WithAdditionalDiagnostics(CreateMissingIdentifierName(), GetExpectedTokenError(SyntaxKind.IdentifierToken, this.CurrentToken.Kind)); 824semicolon = SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken); 835if (type.IsMissing && this.PeekToken(1).Kind == SyntaxKind.SemicolonToken) 838semicolon = this.EatToken(SyntaxKind.SemicolonToken); 846return this.CurrentToken.Kind == SyntaxKind.OpenBracketToken 848&& this.PeekToken(2).Kind == SyntaxKind.ColonToken; 865return this.CurrentToken.Kind == SyntaxKind.OpenBracketToken; 884return this.CurrentToken.Kind == SyntaxKind.CloseBracketToken 890if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.AttributeList) 895var openBracket = this.EatToken(SyntaxKind.OpenBracketToken); 898var location = IsSomeWord(this.CurrentToken.Kind) && this.PeekToken(1).Kind == SyntaxKind.ColonToken 899? _syntaxFactory.AttributeTargetSpecifier(ConvertToKeyword(this.EatToken()), this.EatToken(SyntaxKind.ColonToken)) 904SyntaxKind.CloseBracketToken, 916this.EatToken(SyntaxKind.CloseBracketToken)); 919LanguageParser @this, ref SyntaxToken openBracket, SeparatedSyntaxListBuilder<AttributeSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 922static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleAttribute(), 935if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.Attribute) 947if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.AttributeArgumentList) 952if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 955var openParen = this.EatToken(SyntaxKind.OpenParenToken); 959SyntaxKind.CloseParenToken, 970this.EatToken(SyntaxKind.CloseParenToken)); 973LanguageParser @this, ref SyntaxToken openParen, SeparatedSyntaxListBuilder<AttributeArgumentSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 976static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleAttributeArgument(), 994if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 998case SyntaxKind.EqualsToken: 1001this.EatToken(SyntaxKind.EqualsToken)); 1004case SyntaxKind.ColonToken: 1007this.EatToken(SyntaxKind.ColonToken)); 1020internal static DeclarationModifiers GetModifierExcludingScoped(SyntaxKind kind, SyntaxKind contextualKind) 1024case SyntaxKind.PublicKeyword: 1026case SyntaxKind.InternalKeyword: 1028case SyntaxKind.ProtectedKeyword: 1030case SyntaxKind.PrivateKeyword: 1032case SyntaxKind.SealedKeyword: 1034case SyntaxKind.AbstractKeyword: 1036case SyntaxKind.StaticKeyword: 1038case SyntaxKind.VirtualKeyword: 1040case SyntaxKind.ExternKeyword: 1042case SyntaxKind.NewKeyword: 1044case SyntaxKind.OverrideKeyword: 1046case SyntaxKind.ReadOnlyKeyword: 1048case SyntaxKind.VolatileKeyword: 1050case SyntaxKind.UnsafeKeyword: 1052case SyntaxKind.PartialKeyword: 1054case SyntaxKind.AsyncKeyword: 1056case SyntaxKind.RefKeyword: 1058case SyntaxKind.IdentifierToken: 1061case SyntaxKind.PartialKeyword: 1063case SyntaxKind.AsyncKeyword: 1065case SyntaxKind.RequiredKeyword: 1067case SyntaxKind.FileKeyword: 1114else if (nextToken.Kind == SyntaxKind.NamespaceKeyword) 1120nextToken.Kind is SyntaxKind.EnumKeyword or SyntaxKind.DelegateKeyword || 1141(next.ContextualKind == SyntaxKind.PartialKeyword && 1196Debug.Assert(modTok.Kind is not (SyntaxKind.OutKeyword or SyntaxKind.InKeyword)); 1202if (token.Kind == SyntaxKind.StructKeyword) 1207if (token.ContextualKind == SyntaxKind.RecordKeyword) 1222Debug.Assert(this.CurrentToken.Kind == SyntaxKind.IdentifierToken && GetModifierExcludingScoped(this.CurrentToken) != DeclarationModifiers.None); 1241(this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword)) 1258var currentTokenKind = this.CurrentToken.Kind; 1260currentTokenKind == SyntaxKind.EventKeyword || 1261(currentTokenKind is SyntaxKind.ExplicitKeyword or SyntaxKind.ImplicitKeyword && PeekToken(1).Kind == SyntaxKind.OperatorKeyword)) 1280var currentTokenKind = this.CurrentToken.Kind; 1284if (currentTokenKind == SyntaxKind.EndOfFileToken) 1291if (currentTokenKind == SyntaxKind.CloseBraceToken) 1319if (currentTokenKind == SyntaxKind.NamespaceKeyword) 1324if (!parsingStatementNotDeclaration && currentTokenKind == SyntaxKind.OperatorKeyword) 1340Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword); 1344case SyntaxKind.StructKeyword: 1345case SyntaxKind.ClassKeyword: 1346case SyntaxKind.InterfaceKeyword: 1350if (nextToken.ContextualKind == SyntaxKind.RecordKeyword) 1381Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword); 1398case SyntaxKind.IdentifierToken: 1399if (this.CurrentToken.ContextualKind == SyntaxKind.GlobalKeyword && this.PeekToken(1).Kind == SyntaxKind.UsingKeyword) 1405case SyntaxKind.ThisKeyword: 1421case SyntaxKind.ClassKeyword: 1424case SyntaxKind.StructKeyword: 1427case SyntaxKind.InterfaceKeyword: 1430case SyntaxKind.DelegateKeyword: 1433case SyntaxKind.EnumKeyword: 1436case SyntaxKind.IdentifierToken: 1437Debug.Assert(CurrentToken.ContextualKind == SyntaxKind.RecordKeyword); 1449Debug.Assert(this.CurrentToken.Kind is SyntaxKind.ClassKeyword or SyntaxKind.StructKeyword or SyntaxKind.InterfaceKeyword || 1450this.CurrentToken.ContextualKind == SyntaxKind.RecordKeyword); 1469var paramList = CurrentToken.Kind == SyntaxKind.OpenParenToken 1481if (this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 1492if (CurrentToken.Kind == SyntaxKind.SemicolonToken) 1494semicolon = EatToken(SyntaxKind.SemicolonToken); 1500openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 1516SyntaxKind kind = this.CurrentToken.Kind; 1538else if (kind is SyntaxKind.CloseBraceToken or SyntaxKind.EndOfFileToken || this.IsTerminator()) 1553closeBrace = SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken); 1554closeBrace = WithAdditionalDiagnostics(closeBrace, this.GetExpectedTokenError(SyntaxKind.CloseBraceToken, this.CurrentToken.Kind)); 1558closeBrace = this.EatToken(SyntaxKind.CloseBraceToken); 1561semicolon = TryEatToken(SyntaxKind.SemicolonToken); 1581if (this.CurrentToken.ContextualKind == SyntaxKind.RecordKeyword) 1584recordModifier = this.CurrentToken.Kind is SyntaxKind.ClassKeyword or SyntaxKind.StructKeyword 1591if (this.CurrentToken.Kind is SyntaxKind.StructKeyword or SyntaxKind.ClassKeyword && 1592this.PeekToken(1).ContextualKind == SyntaxKind.RecordKeyword && 1593this.PeekToken(2).Kind is SyntaxKind.IdentifierToken) 1622case SyntaxKind.ClassKeyword: 1637case SyntaxKind.StructKeyword: 1652case SyntaxKind.InterfaceKeyword: 1667case SyntaxKind.RecordKeyword: 1671SyntaxKind declarationKind = recordModifier?.Kind == SyntaxKind.StructKeyword ? SyntaxKind.RecordStructDeclaration : SyntaxKind.RecordDeclaration; 1726SyntaxKind kind = this.CurrentToken.Kind; 1730!(kind == SyntaxKind.DelegateKeyword && this.PeekToken(1).Kind is SyntaxKind.OpenBraceToken or SyntaxKind.OpenParenToken)) 1743case SyntaxKind.OpenBraceToken: 1747case SyntaxKind.CloseBraceToken: 1756case SyntaxKind.EndOfFileToken: 1774return this.IsPossibleMemberStart() || this.CurrentToken.Kind == SyntaxKind.CloseBraceToken; 1779return this.CurrentToken.Kind is SyntaxKind.ColonToken or SyntaxKind.OpenBraceToken 1785var colon = this.TryEatToken(SyntaxKind.ColonToken); 1794var argumentList = this.CurrentToken.Kind == SyntaxKind.OpenParenToken 1805if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken || 1806((_termState & TerminatorState.IsEndOfRecordOrClassOrStructOrInterfaceSignature) != 0 && this.CurrentToken.Kind == SyntaxKind.SemicolonToken) || 1811else if (this.CurrentToken.Kind == SyntaxKind.CommaToken || this.IsPossibleType()) 1813list.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 1817else if (skipBadBaseListTokens(ref colon, list, SyntaxKind.CommaToken) == PostSkipAction.Abort) 1825PostSkipAction skipBadBaseListTokens(ref SyntaxToken colon, SeparatedSyntaxListBuilder<BaseTypeSyntax> list, SyntaxKind expected) 1828static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleAttribute(), 1829static (p, _) => p.CurrentToken.Kind == SyntaxKind.OpenBraceToken || p.IsCurrentTokenWhereOfConstraintClause(), 1837this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword && 1838this.PeekToken(1).Kind == SyntaxKind.IdentifierToken && 1839this.PeekToken(2).Kind == SyntaxKind.ColonToken; 1844while (this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 1852var where = this.EatContextualToken(SyntaxKind.WhereKeyword); 1857var colon = this.EatToken(SyntaxKind.ColonToken); 1862if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken || this.IsCurrentTokenWhereOfConstraintClause()) 1873if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 1874|| ((_termState & TerminatorState.IsEndOfRecordOrClassOrStructOrInterfaceSignature) != 0 && this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 1875|| this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken 1876|| this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 1880else if (this.CurrentToken.Kind == SyntaxKind.CommaToken || this.IsPossibleTypeParameterConstraint()) 1882bounds.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 1893else if (skipBadTypeParameterConstraintTokens(bounds, SyntaxKind.CommaToken) == PostSkipAction.Abort) 1906PostSkipAction skipBadTypeParameterConstraintTokens(SeparatedSyntaxListBuilder<TypeParameterConstraintSyntax> list, SyntaxKind expected) 1911static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleTypeParameterConstraint(), 1912static (p, _) => p.CurrentToken.Kind == SyntaxKind.OpenBraceToken || p.IsCurrentTokenWhereOfConstraintClause(), 1921case SyntaxKind.NewKeyword: 1922case SyntaxKind.ClassKeyword: 1923case SyntaxKind.StructKeyword: 1924case SyntaxKind.DefaultKeyword: 1926case SyntaxKind.IdentifierToken: 1937SyntaxKind.NewKeyword => 1940this.EatToken(SyntaxKind.OpenParenToken), 1941this.EatToken(SyntaxKind.CloseParenToken)), 1943SyntaxKind.StructKeyword => 1945SyntaxKind.StructConstraint, 1947this.CurrentToken.Kind == SyntaxKind.QuestionToken 1948? this.AddError(this.EatToken(), ErrorCode.ERR_UnexpectedToken, SyntaxFacts.GetText(SyntaxKind.QuestionToken)) 1951SyntaxKind.ClassKeyword => 1953SyntaxKind.ClassConstraint, 1955this.TryEatToken(SyntaxKind.QuestionToken)), 1957SyntaxKind.DefaultKeyword => 1960SyntaxKind.EnumKeyword => 1967SyntaxKind.DelegateKeyword => 1968PeekToken(1).Kind == SyntaxKind.AsteriskToken 1983private static bool CanStartMember(SyntaxKind kind) 1987case SyntaxKind.AbstractKeyword: 1988case SyntaxKind.BoolKeyword: 1989case SyntaxKind.ByteKeyword: 1990case SyntaxKind.CharKeyword: 1991case SyntaxKind.ClassKeyword: 1992case SyntaxKind.ConstKeyword: 1993case SyntaxKind.DecimalKeyword: 1994case SyntaxKind.DelegateKeyword: 1995case SyntaxKind.DoubleKeyword: 1996case SyntaxKind.EnumKeyword: 1997case SyntaxKind.EventKeyword: 1998case SyntaxKind.ExternKeyword: 1999case SyntaxKind.FixedKeyword: 2000case SyntaxKind.FloatKeyword: 2001case SyntaxKind.IntKeyword: 2002case SyntaxKind.InterfaceKeyword: 2003case SyntaxKind.InternalKeyword: 2004case SyntaxKind.LongKeyword: 2005case SyntaxKind.NewKeyword: 2006case SyntaxKind.ObjectKeyword: 2007case SyntaxKind.OverrideKeyword: 2008case SyntaxKind.PrivateKeyword: 2009case SyntaxKind.ProtectedKeyword: 2010case SyntaxKind.PublicKeyword: 2011case SyntaxKind.ReadOnlyKeyword: 2012case SyntaxKind.SByteKeyword: 2013case SyntaxKind.SealedKeyword: 2014case SyntaxKind.ShortKeyword: 2015case SyntaxKind.StaticKeyword: 2016case SyntaxKind.StringKeyword: 2017case SyntaxKind.StructKeyword: 2018case SyntaxKind.UIntKeyword: 2019case SyntaxKind.ULongKeyword: 2020case SyntaxKind.UnsafeKeyword: 2021case SyntaxKind.UShortKeyword: 2022case SyntaxKind.VirtualKeyword: 2023case SyntaxKind.VoidKeyword: 2024case SyntaxKind.VolatileKeyword: 2025case SyntaxKind.IdentifierToken: 2026case SyntaxKind.TildeToken: 2027case SyntaxKind.OpenBracketToken: 2028case SyntaxKind.ImplicitKeyword: 2029case SyntaxKind.ExplicitKeyword: 2030case SyntaxKind.OpenParenToken: //tuple 2031case SyntaxKind.RefKeyword: 2043case SyntaxKind.ClassKeyword: 2044case SyntaxKind.DelegateKeyword when !IsFunctionPointerStart(): 2045case SyntaxKind.EnumKeyword: 2046case SyntaxKind.InterfaceKeyword: 2047case SyntaxKind.StructKeyword: 2050case SyntaxKind.IdentifierToken: 2051if (CurrentToken.ContextualKind == SyntaxKind.RecordKeyword) 2066private bool CanReuseMemberDeclaration(SyntaxKind kind, bool isGlobal) 2070case SyntaxKind.ClassDeclaration: 2071case SyntaxKind.StructDeclaration: 2072case SyntaxKind.InterfaceDeclaration: 2073case SyntaxKind.EnumDeclaration: 2074case SyntaxKind.DelegateDeclaration: 2075case SyntaxKind.EventFieldDeclaration: 2076case SyntaxKind.PropertyDeclaration: 2077case SyntaxKind.EventDeclaration: 2078case SyntaxKind.IndexerDeclaration: 2079case SyntaxKind.OperatorDeclaration: 2080case SyntaxKind.ConversionOperatorDeclaration: 2081case SyntaxKind.DestructorDeclaration: 2082case SyntaxKind.ConstructorDeclaration: 2083case SyntaxKind.NamespaceDeclaration: 2084case SyntaxKind.FileScopedNamespaceDeclaration: 2085case SyntaxKind.RecordDeclaration: 2086case SyntaxKind.RecordStructDeclaration: 2088case SyntaxKind.FieldDeclaration: 2089case SyntaxKind.MethodDeclaration: 2098case SyntaxKind.GlobalStatement: 2110const SyntaxKind parentKind = SyntaxKind.StructDeclaration; 2126internal MemberDeclarationSyntax ParseMemberDeclarationOrStatement(SyntaxKind parentKind) 2141private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind parentKind) 2145Debug.Assert(parentKind == SyntaxKind.CompilationUnit); 2189case SyntaxKind.UnsafeKeyword: 2190if (this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken) 2196case SyntaxKind.FixedKeyword: 2197if (this.PeekToken(1).Kind == SyntaxKind.OpenParenToken) 2203case SyntaxKind.DelegateKeyword: 2206case SyntaxKind.OpenParenToken: 2207case SyntaxKind.OpenBraceToken: 2212case SyntaxKind.NewKeyword: 2233if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && this.PeekToken(1).Kind == SyntaxKind.OpenParenToken) 2246this.AddError(SyntaxFactory.MissingToken(SyntaxKind.VoidKeyword), ErrorCode.ERR_MemberNeedsType)); 2267if (this.CurrentToken.Kind == SyntaxKind.ConstKeyword) 2280if (this.CurrentToken.Kind == SyntaxKind.EventKeyword) 2286if (this.CurrentToken.Kind == SyntaxKind.FixedKeyword) 2298if (this.CurrentToken.Kind == SyntaxKind.NamespaceKeyword) 2316if ((!haveAttributes || !IsScript) && !haveModifiers && (type.Kind == SyntaxKind.RefType || !IsOperatorStart(out _, advanceParser: false))) 2320if (this.CurrentToken.Kind is not SyntaxKind.CloseBraceToken and not SyntaxKind.EndOfFileToken && 2410!type.IsMissing && type.Kind != SyntaxKind.RefType && 2546case SyntaxKind.LocalFunctionStatement: 2547case SyntaxKind.ExpressionStatement when 2551statement is ExpressionStatementSyntax { Expression.Kind: SyntaxKind.IdentifierName, SemicolonToken.IsMissing: true }: 2555case SyntaxKind.LocalDeclarationStatement: 2565if (CurrentToken.Kind == SyntaxKind.UsingKeyword) 2570if (CurrentToken.ContextualKind == SyntaxKind.GlobalKeyword && this.PeekToken(1).Kind == SyntaxKind.UsingKeyword) 2586this.CurrentToken.ContextualKind is not (SyntaxKind.PartialKeyword or SyntaxKind.AsyncKeyword or SyntaxKind.RequiredKeyword or SyntaxKind.FileKeyword) && 2605private bool IsNoneOrIncompleteMember(SyntaxKind parentKind, SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers, TypeSyntax type, 2611if (attributes.Count == 0 && modifiers.Count == 0 && type.IsMissing && type.Kind != SyntaxKind.RefType) 2623else if (parentKind is SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration || 2624parentKind == SyntaxKind.CompilationUnit && !IsScript) 2650if (type.Kind != SyntaxKind.RefType && 2653|| this.CurrentToken.Kind is not SyntaxKind.OpenParenToken and not SyntaxKind.OpenBraceToken and not SyntaxKind.EqualsGreaterThanToken) && 2673if (identifierOrThisOpt.Kind == SyntaxKind.ThisKeyword) 2682(this.CurrentToken.Kind is SyntaxKind.SemicolonToken && IsStartOfPropertyBody(this.PeekToken(1).Kind))) 2692private static bool IsStartOfPropertyBody(SyntaxKind kind) 2693=> kind is SyntaxKind.OpenBraceToken or SyntaxKind.EqualsGreaterThanToken; 2696internal MemberDeclarationSyntax ParseMemberDeclaration(SyntaxKind parentKind) 2711private MemberDeclarationSyntax ParseMemberDeclarationCore(SyntaxKind parentKind) 2715Debug.Assert(parentKind != SyntaxKind.CompilationUnit); 2735if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && this.PeekToken(1).Kind == SyntaxKind.OpenParenToken) 2741if (this.CurrentToken.Kind == SyntaxKind.TildeToken) 2747if (this.CurrentToken.Kind == SyntaxKind.ConstKeyword) 2753if (this.CurrentToken.Kind == SyntaxKind.EventKeyword) 2759if (this.CurrentToken.Kind == SyntaxKind.FixedKeyword) 2799if (type.Kind != SyntaxKind.RefType) 2871if (type.Kind != SyntaxKind.IdentifierName) 2874if (identifierOrThisOpt.Kind != SyntaxKind.IdentifierToken) 2878var contextualKind = identifier.ContextualKind; 2879if (contextualKind != SyntaxKind.AsyncKeyword || 2891if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 2896if (this.CurrentToken.ContextualKind == SyntaxKind.GlobalKeyword && this.PeekToken(1).Kind == SyntaxKind.UsingKeyword) 2907var kind = this.PeekToken(1).Kind; 2913kind == SyntaxKind.SemicolonToken && 2921case SyntaxKind.DotToken: // Goo. explicit 2922case SyntaxKind.ColonColonToken: // Goo:: explicit 2923case SyntaxKind.DotDotToken: // Goo.. explicit 2924case SyntaxKind.LessThanToken: // Goo< explicit or generic method 2925case SyntaxKind.OpenBraceToken: // Goo { property 2926case SyntaxKind.EqualsGreaterThanToken: // Goo => property 2928case SyntaxKind.OpenParenToken: // Goo( method 2937return this.CurrentToken.Kind is SyntaxKind.ImplicitKeyword or SyntaxKind.ExplicitKeyword or SyntaxKind.OperatorKeyword; 2959if (token.Kind != SyntaxKind.None) 2979var initializer = this.CurrentToken.Kind == SyntaxKind.ColonToken 2995var colon = this.EatToken(SyntaxKind.ColonToken); 2998var kind = this.CurrentToken.Kind == SyntaxKind.BaseKeyword 2999? SyntaxKind.BaseConstructorInitializer 3000: SyntaxKind.ThisConstructorInitializer; 3003if (this.CurrentToken.Kind is SyntaxKind.BaseKeyword or SyntaxKind.ThisKeyword) 3009token = this.EatToken(SyntaxKind.ThisKeyword, ErrorCode.ERR_ThisOrBaseExpected); 3015var argumentList = this.CurrentToken.Kind == SyntaxKind.OpenParenToken 3018this.EatToken(SyntaxKind.OpenParenToken, reportError), 3020this.EatToken(SyntaxKind.CloseParenToken, reportError)); 3027Debug.Assert(this.CurrentToken.Kind == SyntaxKind.TildeToken); 3028var tilde = this.EatToken(SyntaxKind.TildeToken); 3032this.EatToken(SyntaxKind.OpenParenToken), 3034this.EatToken(SyntaxKind.CloseParenToken)); 3053if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 3057semicolon = this.EatToken(SyntaxKind.SemicolonToken); 3061blockBody = this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 3065expressionBody = this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken 3073semicolon = this.EatToken(SyntaxKind.SemicolonToken); 3076else if (parseSemicolonAfterBlock && this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 3088if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 3094if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 3100if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken) 3116=> this.CurrentToken.Kind is SyntaxKind.SemicolonToken or SyntaxKind.OpenBraceToken; 3120return this.CurrentToken.Kind is SyntaxKind.SemicolonToken or SyntaxKind.OpenBraceToken; 3124=> this.CurrentToken.Kind is SyntaxKind.DotToken or SyntaxKind.ColonColonToken; 3127=> this.CurrentToken.Kind == (errored ? SyntaxKind.CloseParenToken : SyntaxKind.GreaterThanToken); 3130=> this.CurrentToken.Kind == SyntaxKind.CloseBracketToken; 3147if (this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 3152else if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 3174IsInAsync = modifiers.Any((int)SyntaxKind.AsyncKeyword); 3207case SyntaxKind.OpenParenToken: 3208case SyntaxKind.OpenBraceToken: 3209case SyntaxKind.SemicolonToken: 3224if (this.CurrentToken.Kind is not (SyntaxKind.ImplicitKeyword or SyntaxKind.ExplicitKeyword)) 3226SyntaxKind separatorKind = SyntaxKind.None; 3228if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 3238if (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword) 3252(IsMakingProgress(ref lastTokenPosition, assertIfFalse: false) && this.CurrentToken.Kind != SyntaxKind.OpenParenToken)) 3263separatorKind = SyntaxKind.None; 3280if (this.CurrentToken.Kind != SyntaxKind.OperatorKeyword || 3281(haveExplicitInterfaceName && separatorKind is not (SyntaxKind.DotToken or SyntaxKind.DotDotToken))) 3285else if (this.PeekToken(1).Kind is SyntaxKind.CheckedKeyword or SyntaxKind.UncheckedKeyword) 3302var style = this.CurrentToken.Kind is SyntaxKind.ImplicitKeyword or SyntaxKind.ExplicitKeyword 3304: this.EatToken(SyntaxKind.ExplicitKeyword); 3312if (!style.IsMissing && explicitInterfaceOpt is not null && this.CurrentToken.Kind != SyntaxKind.OperatorKeyword && style.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia)) 3318opKeyword = this.EatToken(SyntaxKind.OperatorKeyword); 3330SyntaxFactory.MissingToken(SyntaxKind.OpenParenToken), 3332SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken)), 3335semicolonToken: SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken)); 3338opKeyword = this.EatToken(SyntaxKind.OperatorKeyword); 3344bool couldBeParameterList = this.CurrentToken.Kind == SyntaxKind.OpenParenToken; 3349this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 3380if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 3397if (this.CurrentToken.Kind == SyntaxKind.OperatorKeyword) 3407(IsMakingProgress(ref lastTokenPosition, assertIfFalse: false) && this.CurrentToken.Kind != SyntaxKind.OpenParenToken); 3414if (separator?.Kind == SyntaxKind.ColonColonToken) 3417separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 3434if (separator.Kind != SyntaxKind.DotToken) 3436separator = WithAdditionalDiagnostics(separator, GetExpectedTokenError(SyntaxKind.DotToken, separator.Kind, separator.GetLeadingTriviaWidth(), separator.Width)); 3437separator = ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 3446if (CurrentToken.Kind == SyntaxKind.UncheckedKeyword) 3454return TryEatToken(SyntaxKind.CheckedKeyword); 3463var opKeyword = this.EatToken(SyntaxKind.OperatorKeyword); 3478if (this.CurrentToken.Kind is SyntaxKind.ImplicitKeyword or SyntaxKind.ExplicitKeyword) 3482opToken = this.ConvertToMissingWithTrailingTrivia(this.EatToken(), SyntaxKind.PlusToken); 3489SyntaxDiagnosticInfo diagInfo = MakeError(opTokenErrorOffset, opTokenErrorWidth, ErrorCode.ERR_BadOperatorSyntax, SyntaxFacts.GetText(SyntaxKind.PlusToken)); 3495type = this.AddError(type, ErrorCode.ERR_BadOperatorSyntax, SyntaxFacts.GetText(SyntaxKind.PlusToken)); 3510var opKind = opToken.Kind; 3512if (opToken.Kind == SyntaxKind.GreaterThanToken && tk.Kind == SyntaxKind.GreaterThanToken && 3518if (tk.Kind == SyntaxKind.GreaterThanToken && 3522opToken = SyntaxFactory.Token(opToken.GetLeadingTrivia(), SyntaxKind.GreaterThanGreaterThanGreaterThanToken, opToken2.GetTrailingTrivia()); 3526opToken = SyntaxFactory.Token(opToken.GetLeadingTrivia(), SyntaxKind.GreaterThanGreaterThanToken, opToken2.GetTrailingTrivia()); 3576if (!(opKind == SyntaxKind.IsKeyword || 3580opToken = ConvertToMissingWithTrailingTrivia(opToken, SyntaxKind.PlusToken); 3605Debug.Assert(thisKeyword.Kind == SyntaxKind.ThisKeyword); 3621if (this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken) 3624semicolon = this.EatToken(SyntaxKind.SemicolonToken); 3629if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 3638if (this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken 3642semicolon = this.EatToken(SyntaxKind.SemicolonToken); 3673if (this.CurrentToken.Kind is SyntaxKind.SemicolonToken) 3675identifier = AddTrailingSkippedSyntax(identifier, this.EatTokenWithPrejudice(SyntaxKind.OpenBraceToken)); 3681var accessorList = this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 3689if (this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken) 3694else if (this.CurrentToken.Kind == SyntaxKind.EqualsToken) 3696var equals = this.EatToken(SyntaxKind.EqualsToken); 3704semicolon = this.EatToken(SyntaxKind.SemicolonToken); 3706else if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 3725var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 3735if (this.CurrentToken.Kind == SyntaxKind.CloseBraceToken) 3757this.EatToken(SyntaxKind.CloseBraceToken)); 3763this.EatToken(SyntaxKind.EqualsGreaterThanToken), 3770var refKeyword = this.CurrentToken.Kind == SyntaxKind.RefKeyword && !this.IsPossibleLambdaExpression(Precedence.Expression) 3781static p => p.CurrentToken.Kind != SyntaxKind.CloseBraceToken && !p.IsPossibleAccessor(), 3788return this.CurrentToken.Kind == SyntaxKind.IdentifierToken 3790|| SyntaxFacts.GetAccessorDeclarationKind(this.CurrentToken.ContextualKind) != SyntaxKind.None 3791|| this.CurrentToken.Kind == SyntaxKind.OpenBraceToken // for accessor blocks w/ missing keyword 3792|| this.CurrentToken.Kind == SyntaxKind.SemicolonToken // for empty body accessors w/ missing keyword 3826if (token.Kind is SyntaxKind.CloseBraceToken or SyntaxKind.EndOfFileToken) 3835case SyntaxKind.GetKeyword: 3836case SyntaxKind.SetKeyword: 3837case SyntaxKind.InitKeyword: 3838case SyntaxKind.AddKeyword: 3839case SyntaxKind.RemoveKeyword: 3856Func<LanguageParser, SyntaxKind, bool> abortFunction, 3857SyntaxKind expected, 3858SyntaxKind closeKind = SyntaxKind.None) 3898Func<LanguageParser, SyntaxKind, bool> abortFunction, 3899SyntaxKind expected, 3900SyntaxKind closeKind, 3946Func<LanguageParser, SyntaxKind, bool> abortFunction, 3947SyntaxKind expected, 3948SyntaxKind closeKind, 4009var accessorName = this.EatToken(SyntaxKind.IdentifierToken, 4011var accessorKind = GetAccessorKind(accessorName); 4016if (accessorKind == SyntaxKind.UnknownAccessorDeclaration) 4042bool currentTokenIsSemicolon = this.CurrentToken.Kind == SyntaxKind.SemicolonToken; 4043bool currentTokenIsArrow = this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken; 4044bool currentTokenIsOpenBraceToken = this.CurrentToken.Kind == SyntaxKind.OpenBraceToken; 4064if (accessorKind != SyntaxKind.UnknownAccessorDeclaration) 4095=> this.EatToken(SyntaxKind.SemicolonToken, 4100private static SyntaxKind GetAccessorKind(SyntaxToken accessorName) 4104SyntaxKind.GetKeyword => SyntaxKind.GetAccessorDeclaration, 4105SyntaxKind.SetKeyword => SyntaxKind.SetAccessorDeclaration, 4106SyntaxKind.InitKeyword => SyntaxKind.InitAccessorDeclaration, 4107SyntaxKind.AddKeyword => SyntaxKind.AddAccessorDeclaration, 4108SyntaxKind.RemoveKeyword => SyntaxKind.RemoveAccessorDeclaration, 4109_ => SyntaxKind.UnknownAccessorDeclaration, 4120var parameters = this.ParseParameterList(out var open, out var close, SyntaxKind.OpenParenToken, SyntaxKind.CloseParenToken); 4131var parameters = this.ParseParameterList(out var open, out var close, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken); 4194SyntaxKind openKind, 4195SyntaxKind closeKind) 4218LanguageParser @this, ref SyntaxToken open, SeparatedSyntaxListBuilder<ParameterSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 4221static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleParameter(), 4229return this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken or SyntaxKind.SemicolonToken; 4236case SyntaxKind.OpenBracketToken: // attribute 4237case SyntaxKind.ArgListKeyword: 4238case SyntaxKind.OpenParenToken: // tuple 4239case SyntaxKind.DelegateKeyword when IsFunctionPointerStart(): // Function pointer type 4242case SyntaxKind.IdentifierToken: 4268if (parent.Kind() == SyntaxKind.SimpleLambdaExpression) 4274if (grandparent != null && grandparent.Kind() == SyntaxKind.ParenthesizedLambdaExpression) 4276Debug.Assert(parent.Kind() == SyntaxKind.ParameterList); 4298if (this.CurrentToken.Kind == SyntaxKind.ArgListKeyword) 4303attributes, modifiers.ToList(), type: null, this.EatToken(SyntaxKind.ArgListKeyword), @default: null); 4309if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && IsCurrentTokenWhereOfConstraintClause()) 4319if (this.CurrentToken.Kind is SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken) 4329equalsToken ??= TryEatToken(SyntaxKind.EqualsToken); 4350if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken) 4358this.AddError(SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, "!", "!", trailing: null), ErrorCode.ERR_ParameterNullCheckingNotSupported)); 4361equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia()); 4363else if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken) 4368if (this.CurrentToken.Kind is SyntaxKind.ExclamationToken) 4372else if (this.CurrentToken.Kind is SyntaxKind.ExclamationEqualsToken) 4379SyntaxFactory.Token(exclamationEquals.GetLeadingTrivia(), SyntaxKind.ExclamationToken, trailing: null)); 4380equalsToken = SyntaxFactory.Token(leading: null, SyntaxKind.EqualsToken, exclamationEquals.GetTrailingTrivia()); 4394private SyntaxToken? MergeAdjacent(SyntaxToken t1, SyntaxToken t2, SyntaxKind kind) 4398Debug.Assert(Blender.Reader.IsFabricatedToken(kind) || kind == SyntaxKind.EqualsGreaterThanToken); 4422case SyntaxKind.ThisKeyword: 4423case SyntaxKind.RefKeyword: 4424case SyntaxKind.OutKeyword: 4425case SyntaxKind.InKeyword: 4426case SyntaxKind.ParamsKeyword: 4428case SyntaxKind.ReadOnlyKeyword: 4441if (this.CurrentToken.Kind is SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword) 4458if (this.CurrentToken.Kind is (SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword)) 4469SyntaxKind parentKind) 4471Debug.Assert(this.CurrentToken.Kind == SyntaxKind.FixedKeyword); 4487this.EatToken(SyntaxKind.SemicolonToken)); 4498SyntaxKind parentKind) 4500Debug.Assert(this.CurrentToken.Kind == SyntaxKind.EventKeyword); 4505return IsFieldDeclaration(isEvent: true, isGlobalScriptLevel: parentKind == SyntaxKind.CompilationUnit) 4524if (explicitInterfaceOpt != null && this.CurrentToken.Kind is not SyntaxKind.OpenBraceToken and not SyntaxKind.SemicolonToken) 4537SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken), 4539SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)), 4549else if (identifierOrThisOpt.Kind != SyntaxKind.IdentifierToken) 4551Debug.Assert(identifierOrThisOpt.Kind == SyntaxKind.ThisKeyword); 4552identifier = ConvertToMissingWithTrailingTrivia(identifierOrThisOpt, SyntaxKind.IdentifierToken); 4560Debug.Assert(identifier.Kind == SyntaxKind.IdentifierToken); 4576if (explicitInterfaceOpt != null && this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 4578semicolon = this.EatToken(SyntaxKind.SemicolonToken); 4603if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 4617SyntaxKind parentKind) 4627if (modifiers is [.., SyntaxToken { Kind: SyntaxKind.ScopedKeyword } scopedKeyword]) 4633var semicolon = this.EatToken(SyntaxKind.SemicolonToken); 4651SyntaxKind parentKind) 4673if (this.CurrentToken.Kind == SyntaxKind.DotToken) 4678var semicolon = this.EatToken(SyntaxKind.SemicolonToken); 4694return this.CurrentToken.Kind == SyntaxKind.SemicolonToken; 4697private void ParseVariableDeclarators(TypeSyntax type, VariableFlags flags, SeparatedSyntaxListBuilder<VariableDeclaratorSyntax> variables, SyntaxKind parentKind) 4702parentKind is not SyntaxKind.NamespaceDeclaration and not SyntaxKind.FileScopedNamespaceDeclaration && 4703(parentKind != SyntaxKind.CompilationUnit || IsScript); 4748if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 4752else if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 4754variables.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 4767else if (!variableDeclarationsExpected || this.SkipBadVariableListTokens(variables, SyntaxKind.CommaToken) == PostSkipAction.Abort) 4774private PostSkipAction SkipBadVariableListTokens(SeparatedSyntaxListBuilder<VariableDeclaratorSyntax> list, SyntaxKind expected) 4779static p => p.CurrentToken.Kind != SyntaxKind.CommaToken, 4780static (p, _) => p.CurrentToken.Kind == SyntaxKind.SemicolonToken, 4798case SyntaxKind.FieldDeclaration: 4800case SyntaxKind.MethodDeclaration: 4802case SyntaxKind.ConstructorDeclaration: 4804case SyntaxKind.DestructorDeclaration: 4806case SyntaxKind.PropertyDeclaration: 4808case SyntaxKind.EventFieldDeclaration: 4810case SyntaxKind.AddAccessorDeclaration: 4811case SyntaxKind.RemoveAccessorDeclaration: 4812case SyntaxKind.GetAccessorDeclaration: 4813case SyntaxKind.SetAccessorDeclaration: 4814case SyntaxKind.InitAccessorDeclaration: 4816case SyntaxKind.ClassDeclaration: 4817case SyntaxKind.StructDeclaration: 4818case SyntaxKind.InterfaceDeclaration: 4819case SyntaxKind.RecordDeclaration: 4820case SyntaxKind.RecordStructDeclaration: 4822case SyntaxKind.DelegateDeclaration: 4845if (mods.Any(SyntaxKind.FixedKeyword)) 4850if (mods.Any(SyntaxKind.ConstKeyword)) 4855if (parent != null && (parent.Kind() == SyntaxKind.VariableDeclaration || parent.Kind() == SyntaxKind.LocalDeclarationStatement)) 4870SyntaxKind oldKind; 4875&& (oldKind = GetOldParent(old).Kind()) != SyntaxKind.VariableDeclaration // or in a method body 4876&& oldKind != SyntaxKind.LocalDeclarationStatement; 4932var currentTokenKind = this.CurrentToken.Kind; 4933if (currentTokenKind == SyntaxKind.IdentifierToken && !parentType.IsMissing) 4935var isAfterNewLine = parentType.GetLastToken().TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia); 4945currentTokenKind != SyntaxKind.EqualsToken && 4948if (currentTokenKind is SyntaxKind.DotToken or SyntaxKind.OpenParenToken or SyntaxKind.MinusGreaterThanToken || 4951var isPossibleLocalFunctionToken = currentTokenKind is SyntaxKind.OpenParenToken or SyntaxKind.LessThanToken; 4995case SyntaxKind.EqualsToken: 5004var refKeyword = isLocalOrField && !isConst && this.CurrentToken.Kind == SyntaxKind.RefKeyword && !this.IsPossibleLambdaExpression(Precedence.Expression) 5014case SyntaxKind.LessThanToken: 5025case SyntaxKind.OpenParenToken: 5043case SyntaxKind.OpenBracketToken: 5062bool isOmitted = expression.Kind == SyntaxKind.OmittedArraySizeExpression; 5081if (this.CurrentToken.Kind == SyntaxKind.EqualsToken) 5083goto case SyntaxKind.EqualsToken; 5096if (parentType.Kind == SyntaxKind.ArrayType) 5103goto case SyntaxKind.OpenBracketToken; 5117Debug.Assert(this.CurrentToken.Kind is SyntaxKind.OpenParenToken or SyntaxKind.LessThanToken); 5125(this.CurrentToken.Kind is SyntaxKind.OpenBraceToken or SyntaxKind.EqualsGreaterThanToken || 5126this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword)) 5138case SyntaxKind.CommaToken: 5139case SyntaxKind.SemicolonToken: 5148return this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 5155return this.CurrentToken.Kind == SyntaxKind.OpenBraceToken || this.IsPossibleExpression(); 5158private FieldDeclarationSyntax ParseConstantFieldDeclaration(SyntaxList<AttributeListSyntax> attributes, SyntaxListBuilder modifiers, SyntaxKind parentKind) 5160modifiers.Add(this.EatToken(SyntaxKind.ConstKeyword)); 5170this.EatToken(SyntaxKind.SemicolonToken)); 5175Debug.Assert(this.CurrentToken.Kind == SyntaxKind.DelegateKeyword); 5177var delegateToken = this.EatToken(SyntaxKind.DelegateKeyword); 5186if (this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 5203this.EatToken(SyntaxKind.SemicolonToken)); 5208Debug.Assert(this.CurrentToken.Kind == SyntaxKind.EnumKeyword); 5210var enumToken = this.EatToken(SyntaxKind.EnumKeyword); 5223if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 5225var colon = this.EatToken(SyntaxKind.ColonToken); 5239if (CurrentToken.Kind == SyntaxKind.SemicolonToken) 5241semicolon = EatToken(SyntaxKind.SemicolonToken); 5247openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 5256SyntaxKind.CloseBraceToken, 5265closeBrace = this.EatToken(SyntaxKind.CloseBraceToken); 5266semicolon = TryEatToken(SyntaxKind.SemicolonToken); 5281LanguageParser @this, ref SyntaxToken openBrace, SeparatedSyntaxListBuilder<EnumMemberDeclarationSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 5284static p => p.CurrentToken.Kind is not SyntaxKind.CommaToken and not SyntaxKind.SemicolonToken && !p.IsPossibleEnumMemberDeclaration(), 5292if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.EnumMemberDeclaration) 5300if (this.CurrentToken.Kind == SyntaxKind.EqualsToken) 5304this.EatToken(SyntaxKind.EqualsToken), 5305this.CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.CloseBraceToken 5315return this.CurrentToken.Kind == SyntaxKind.OpenBracketToken || this.IsTrueIdentifier(); 5320return this.CurrentToken.Kind is SyntaxKind.DotToken or SyntaxKind.ColonColonToken; 5336return SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken); 5359if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 5379token.Kind == SyntaxKind.IdentifierToken && 5385if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.IdentifierName) 5399var ctk = this.CurrentToken.Kind; 5400if (ctk == SyntaxKind.IdentifierToken) 5417if (this.IsInAsync && identifierToken.ContextualKind == SyntaxKind.AwaitKeyword) 5437if (this.CurrentToken.ContextualKind == SyntaxKind.PartialKeyword) 5450if (this.CurrentToken.Kind != SyntaxKind.LessThanToken) 5458var open = this.EatToken(SyntaxKind.LessThanToken); 5461SyntaxKind.GreaterThanToken, 5474this.EatToken(SyntaxKind.GreaterThanToken)); 5477LanguageParser @this, ref SyntaxToken open, SeparatedSyntaxListBuilder<TypeParameterSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 5480static p => p.CurrentToken.Kind != SyntaxKind.CommaToken, 5492if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind != SyntaxKind.CloseBracketToken) 5496if (this.CurrentToken.Kind is SyntaxKind.InKeyword or SyntaxKind.OutKeyword) 5513if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind != SyntaxKind.CloseBracketToken) 5523this.CurrentToken.Kind is SyntaxKind.InKeyword or SyntaxKind.OutKeyword ? EatToken() : null, 5540if (this.CurrentToken.Kind == SyntaxKind.LessThanToken) 5550Debug.Assert(this.CurrentToken.Kind == SyntaxKind.LessThanToken); 5575if (this.CurrentToken.Kind != SyntaxKind.LessThanToken) 5623Debug.Assert(greaterThanToken.Kind == SyntaxKind.GreaterThanToken); 5627case SyntaxKind.OpenParenToken: 5628case SyntaxKind.CloseParenToken: 5629case SyntaxKind.CloseBracketToken: 5630case SyntaxKind.CloseBraceToken: 5631case SyntaxKind.ColonToken: 5632case SyntaxKind.SemicolonToken: 5633case SyntaxKind.CommaToken: 5634case SyntaxKind.DotToken: 5635case SyntaxKind.QuestionToken: 5636case SyntaxKind.EqualsEqualsToken: 5637case SyntaxKind.ExclamationEqualsToken: 5638case SyntaxKind.BarToken: 5639case SyntaxKind.CaretToken: 5643case SyntaxKind.AmpersandAmpersandToken: // e.g. `e is A<B> && e` 5644case SyntaxKind.BarBarToken: // e.g. `e is A<B> || e` 5645case SyntaxKind.AmpersandToken: // e.g. `e is A<B> & e` 5646case SyntaxKind.OpenBracketToken: // e.g. `e is A<B>[]` 5647case SyntaxKind.LessThanToken: // e.g. `e is A<B> < C` 5648case SyntaxKind.LessThanEqualsToken: // e.g. `e is A<B> <= C` 5649case SyntaxKind.GreaterThanEqualsToken: // e.g. `e is A<B> >= C` 5650case SyntaxKind.IsKeyword: // e.g. `e is A<B> is bool` 5651case SyntaxKind.AsKeyword: // e.g. `e is A<B> as bool` 5655case SyntaxKind.OpenBraceToken: // e.g. `e is A<B> {}` 5659case SyntaxKind.GreaterThanToken when ((options & NameOptions.AfterIs) != 0) && this.PeekToken(1).Kind != SyntaxKind.GreaterThanToken: 5669case SyntaxKind.IdentifierToken: 5680(options & NameOptions.AfterTupleComma) != 0 && this.PeekToken(1).Kind is SyntaxKind.CommaToken or SyntaxKind.CloseParenToken || 5681(options & NameOptions.FirstElementOfPossibleTupleLiteral) != 0 && this.PeekToken(1).Kind == SyntaxKind.CommaToken) 5689case SyntaxKind.EndOfFileToken: // e.g. `e is A<B>` 5693case SyntaxKind.EqualsGreaterThanToken: // e.g. `e switch { A<B> => 1 }` 5707Debug.Assert(this.CurrentToken.Kind == SyntaxKind.LessThanToken); 5717while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 5720Debug.Assert(start.Kind == SyntaxKind.LessThanToken); 5721Debug.Assert(greaterThanToken.Kind == SyntaxKind.GreaterThanToken); 5733if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken) 5739if (this.CurrentToken.Kind == SyntaxKind.GreaterThanToken) 5822isDefinitelyTypeArgumentList = this.CurrentToken.Kind == SyntaxKind.CommaToken; 5832while (this.CurrentToken.Kind == SyntaxKind.CommaToken); 5834if (this.CurrentToken.Kind != SyntaxKind.GreaterThanToken) 5848isDefinitelyTypeArgumentList = this.CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.GreaterThanToken; 5857Debug.Assert(this.CurrentToken.Kind == SyntaxKind.LessThanToken); 5859open = this.EatToken(SyntaxKind.LessThanToken); 5865var omittedTypeArgumentInstance = _syntaxFactory.OmittedTypeArgument(SyntaxFactory.Token(SyntaxKind.OmittedTypeArgumentToken)); 5867while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 5869types.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 5873close = this.EatToken(SyntaxKind.GreaterThanToken); 5884if (this.CurrentToken.Kind == SyntaxKind.GreaterThanToken) 5888else if (this.CurrentToken.Kind == SyntaxKind.CommaToken || this.IsPossibleType()) 5890types.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 5893else if (this.SkipBadTypeArgumentListTokens(types, SyntaxKind.CommaToken) == PostSkipAction.Abort) 5899close = this.EatToken(SyntaxKind.GreaterThanToken); 5902private PostSkipAction SkipBadTypeArgumentListTokens(SeparatedSyntaxListBuilder<TypeSyntax> list, SyntaxKind expected) 5907static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleType(), 5908static (p, _) => p.CurrentToken.Kind == SyntaxKind.GreaterThanToken, 5916if (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken && this.PeekToken(1).Kind != SyntaxKind.CloseBracketToken) 5932var varianceToken = this.CurrentToken.Kind is SyntaxKind.InKeyword or SyntaxKind.OutKeyword 5959this.CurrentToken.Kind is not SyntaxKind.CommaToken and not SyntaxKind.GreaterThanToken && 5960this.PeekToken(1).Kind is SyntaxKind.CommaToken or SyntaxKind.GreaterThanToken) 5981=> this.CurrentToken.Kind == SyntaxKind.GreaterThanToken; 5985Debug.Assert(this.CurrentToken.Kind == SyntaxKind.LessThanToken); 5987while (this.PeekToken(n).Kind == SyntaxKind.CommaToken) 5990return this.PeekToken(n).Kind == SyntaxKind.GreaterThanToken; 6023if (this.CurrentToken.Kind == SyntaxKind.ThisKeyword) 6049if (separator != null && separator.Kind == SyntaxKind.ColonColonToken) 6052separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6068if (separator.Kind != SyntaxKind.DotToken) 6070separator = WithAdditionalDiagnostics(separator, GetExpectedTokenError(SyntaxKind.DotToken, separator.Kind, separator.GetLeadingTriviaWidth(), separator.Width)); 6071separator = ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6074if (isEvent && this.CurrentToken.Kind is not SyntaxKind.OpenBraceToken and not SyntaxKind.SemicolonToken) 6107if (separator.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia)) 6145if (this.CurrentToken.Kind == SyntaxKind.DotDotToken) 6153separator = this.CurrentToken.Kind == SyntaxKind.ColonColonToken 6155: this.EatToken(SyntaxKind.DotToken); 6167if (this.CurrentToken.Kind == SyntaxKind.ColonColonToken) 6171separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6173else if (this.CurrentToken.Kind == SyntaxKind.DotDotToken) 6181separator = this.EatToken(SyntaxKind.DotToken); 6202if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 6238if (separator != null && separator.Kind == SyntaxKind.ColonColonToken) 6241separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6265if (separator.Kind != SyntaxKind.DotToken) 6267separator = WithAdditionalDiagnostics(separator, GetExpectedTokenError(SyntaxKind.DotToken, separator.Kind, separator.GetLeadingTriviaWidth(), separator.Width)); 6268separator = ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6278return this.CurrentToken.Kind == SyntaxKind.ColonColonToken 6290if (this.PeekToken(1).Kind == SyntaxKind.ThisKeyword) 6304return this.IsDotOrColonColon() || this.CurrentToken.Kind == SyntaxKind.DotDotToken; 6312Debug.Assert(separator.Kind is SyntaxKind.DotToken or SyntaxKind.DotDotToken or SyntaxKind.ColonColonToken); 6317case SyntaxKind.DotToken: 6319case SyntaxKind.DotDotToken: 6323case SyntaxKind.ColonColonToken: 6324if (left.Kind != SyntaxKind.IdentifierName) 6335separator = this.ConvertToMissingWithTrailingTrivia(separator, SyntaxKind.DotToken); 6340if (identifierLeft.Identifier.ContextualKind == SyntaxKind.GlobalKeyword) 6357Debug.Assert(separator.Kind == SyntaxKind.DotDotToken); 6359var leftDot = SyntaxFactory.Token(separator.LeadingTrivia.Node, SyntaxKind.DotToken, null); 6361separator = SyntaxFactory.Token(null, SyntaxKind.DotToken, separator.TrailingTrivia.Node); 6365private SyntaxToken ConvertToMissingWithTrailingTrivia(SyntaxToken token, SyntaxKind expectedKind) 6426var tk = this.CurrentToken.Kind; 6447if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken || !this.IsTrueIdentifier()) 6454if (this.CurrentToken.Kind == SyntaxKind.LessThanToken) 6469if (this.CurrentToken.Kind == SyntaxKind.RefKeyword) 6474if (this.CurrentToken.Kind == SyntaxKind.ReadOnlyKeyword) 6481if (this.CurrentToken.Kind is SyntaxKind.IdentifierToken or SyntaxKind.ColonColonToken) 6484if (this.CurrentToken.Kind is SyntaxKind.ColonColonToken) 6498Debug.Assert(this.CurrentToken.Kind is SyntaxKind.IdentifierToken); 6501isAlias = this.PeekToken(1).Kind == SyntaxKind.ColonColonToken; 6544else if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 6549if (result == ScanTypeFlags.NotType || mode == ParseTypeMode.DefinitePattern && this.CurrentToken.Kind != SyntaxKind.OpenBracketToken) 6571case SyntaxKind.QuestionToken 6572when lastTokenOfType.Kind is not SyntaxKind.QuestionToken // don't allow `Type??` 6573and not SyntaxKind.AsteriskToken: // don't allow `Type*?` 6577case SyntaxKind.AsteriskToken 6578when lastTokenOfType.Kind != SyntaxKind.CloseBracketToken: // don't allow `Type[]*` 6608case SyntaxKind.OpenBracketToken: 6611while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 6616if (this.CurrentToken.Kind != SyntaxKind.CloseBracketToken) 6649if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 6667while (this.CurrentToken.Kind == SyntaxKind.CommaToken); 6669if (this.CurrentToken.Kind == SyntaxKind.CloseParenToken) 6686_ = EatToken(SyntaxKind.DelegateKeyword); 6687lastTokenOfType = EatToken(SyntaxKind.AsteriskToken); 6691if (CurrentToken.Kind == SyntaxKind.IdentifierToken) 6696case { ContextualKind: SyntaxKind.ManagedKeyword }: 6697case { ContextualKind: SyntaxKind.UnmanagedKeyword }: 6699case var _ when peek1.Kind == SyntaxKind.OpenBracketToken: 6709if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) 6711lastTokenOfType = EatToken(SyntaxKind.OpenBracketToken); 6719lastTokenOfType = TryEatToken(SyntaxKind.IdentifierToken) ?? lastTokenOfType; 6726Debug.Assert(CurrentToken.Kind == SyntaxKind.CommaToken); 6730lastTokenOfType = TryEatToken(SyntaxKind.CloseBracketToken) ?? lastTokenOfType; 6749var validStartingToken = EatToken().Kind == SyntaxKind.LessThanToken; 6769_ = EatToken(SyntaxKind.CommaToken); 6779if (!validStartingToken && CurrentToken.Kind == SyntaxKind.CloseParenToken) 6781lastTokenOfType = EatTokenAsKind(SyntaxKind.GreaterThanToken); 6785lastTokenOfType = EatToken(SyntaxKind.GreaterThanToken); 6793isNotExpectedFunction: static p => p.CurrentToken.Kind != SyntaxKind.CommaToken, 6795expected: SyntaxKind.CommaToken, 6796closeKind: SyntaxKind.None, 6802private static bool IsPredefinedType(SyntaxKind keyword) 6814if (this.CurrentToken.Kind == SyntaxKind.VoidKeyword && this.PeekToken(1).Kind != SyntaxKind.AsteriskToken) 6839if (this.CurrentToken.Kind == SyntaxKind.RefKeyword) 6843this.CurrentToken.Kind == SyntaxKind.ReadOnlyKeyword ? this.EatToken() : null, 6889case SyntaxKind.QuestionToken when canBeNullableType(): 6903if (type.Kind == SyntaxKind.NullableType || type.Kind == SyntaxKind.PointerType) 6905if (this.PeekToken(1).Kind == SyntaxKind.OpenBracketToken) 6909if (mode == ParseTypeMode.NewExpression && type.Kind == SyntaxKind.TupleType && 6910this.PeekToken(1).Kind is not SyntaxKind.OpenParenToken and not SyntaxKind.OpenBraceToken) 6917case SyntaxKind.AsteriskToken when type.Kind != SyntaxKind.ArrayType: 6941case SyntaxKind.OpenBracketToken: 6949while (this.CurrentToken.Kind == SyntaxKind.OpenBracketToken); 6966Debug.Assert(this.CurrentToken.Kind == SyntaxKind.QuestionToken); 6997this.CurrentToken.Kind is SyntaxKind.OpenParenToken or // ctor parameters 6998SyntaxKind.OpenBracketToken or // array type 6999SyntaxKind.OpenBraceToken; // object initializer 7013case SyntaxKind.AsteriskToken: 7015case SyntaxKind.OpenBracketToken: 7027var open = this.EatToken(SyntaxKind.OpenBracketToken); 7030var omittedArraySizeExpressionInstance = _syntaxFactory.OmittedArraySizeExpression(SyntaxFactory.Token(SyntaxKind.OmittedArraySizeExpressionToken)); 7032while (IsMakingProgress(ref lastTokenPosition) && this.CurrentToken.Kind != SyntaxKind.CloseBracketToken) 7034if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 7047if (this.CurrentToken.Kind != SyntaxKind.CloseBracketToken) 7049list.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 7052else if (this.SkipBadArrayRankSpecifierTokens(ref open, list, SyntaxKind.CommaToken) == PostSkipAction.Abort) 7072if (list[i].RawKind == (int)SyntaxKind.OmittedArraySizeExpression) 7084this.EatToken(SyntaxKind.CloseBracketToken)); 7089var open = this.EatToken(SyntaxKind.OpenParenToken); 7092if (this.CurrentToken.Kind != SyntaxKind.CloseParenToken) 7096while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 7098list.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 7110list.AddSeparator(SyntaxFactory.MissingToken(SyntaxKind.CommaToken)); 7118this.EatToken(SyntaxKind.CloseParenToken)); 7128private PostSkipAction SkipBadArrayRankSpecifierTokens(ref SyntaxToken openBracket, SeparatedSyntaxListBuilder<ExpressionSyntax> list, SyntaxKind expected) 7131static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleExpression(), 7132static (p, _) => p.CurrentToken.Kind == SyntaxKind.CloseBracketToken, 7142if (token.Kind == SyntaxKind.VoidKeyword && this.CurrentToken.Kind != SyntaxKind.AsteriskToken) 7151if (IsTrueIdentifier() || this.CurrentToken.Kind == SyntaxKind.ColonColonToken) 7156if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 7174var @delegate = EatToken(SyntaxKind.DelegateKeyword); 7175var asterisk = EatToken(SyntaxKind.AsteriskToken); 7181var lessThanTokenError = WithAdditionalDiagnostics(SyntaxFactory.MissingToken(SyntaxKind.LessThanToken), GetExpectedTokenError(SyntaxKind.LessThanToken, SyntaxKind.None)); 7196TryEatToken(SyntaxKind.GreaterThanToken) ?? SyntaxFactory.MissingToken(SyntaxKind.GreaterThanToken))); 7199var lessThanToken = EatTokenAsKind(SyntaxKind.LessThanToken); 7222Debug.Assert(CurrentToken.Kind == SyntaxKind.CommaToken); 7223types.AddSeparator(EatToken(SyntaxKind.CommaToken)); 7233lessThanToken.IsMissing && CurrentToken.Kind == SyntaxKind.CloseParenToken 7234? EatTokenAsKind(SyntaxKind.GreaterThanToken) 7235: EatToken(SyntaxKind.GreaterThanToken))); 7248isNotExpectedFunction: static p => p.CurrentToken.Kind != SyntaxKind.CommaToken, 7251expected: SyntaxKind.CommaToken); 7256if (CurrentToken.Kind == SyntaxKind.IdentifierToken) 7262case { ContextualKind: SyntaxKind.ManagedKeyword }: 7263case { ContextualKind: SyntaxKind.UnmanagedKeyword }: 7269managedSpecifier = EatTokenAsKind(SyntaxKind.ManagedKeyword); 7272case var _ when peek1.Kind == SyntaxKind.OpenBracketToken: 7274managedSpecifier = EatTokenAsKind(SyntaxKind.UnmanagedKeyword); 7284if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) 7286var openBracket = EatToken(SyntaxKind.OpenBracketToken); 7295callingConventionModifiers.Add(SyntaxFactory.FunctionPointerUnmanagedCallingConvention(EatToken(SyntaxKind.IdentifierToken))); 7302Debug.Assert(CurrentToken.Kind == SyntaxKind.CommaToken); 7303callingConventionModifiers.AddSeparator(EatToken(SyntaxKind.CommaToken)); 7306var closeBracket = EatToken(SyntaxKind.CloseBracketToken); 7318if (managedSpecifier.Kind == SyntaxKind.ManagedKeyword && unmanagedCallingConventions != null) 7332=> CurrentToken.Kind == SyntaxKind.DelegateKeyword && PeekToken(1).Kind == SyntaxKind.AsteriskToken; 7337=> token.Kind == SyntaxKind.LessThanToken || token.Kind == SyntaxKind.OpenParenToken; 7343while (this.CurrentToken.Kind == SyntaxKind.AsteriskToken) 7355static @this => SyntaxFactory.EmptyStatement(attributeLists: default, SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken))); 7382case SyntaxKind.FixedKeyword: 7384case SyntaxKind.BreakKeyword: 7386case SyntaxKind.ContinueKeyword: 7388case SyntaxKind.TryKeyword: 7389case SyntaxKind.CatchKeyword: 7390case SyntaxKind.FinallyKeyword: 7392case SyntaxKind.CheckedKeyword: 7393case SyntaxKind.UncheckedKeyword: 7395case SyntaxKind.DoKeyword: 7397case SyntaxKind.ForKeyword: 7399case SyntaxKind.ForEachKeyword: 7401case SyntaxKind.GotoKeyword: 7403case SyntaxKind.IfKeyword: 7405case SyntaxKind.ElseKeyword: 7408case SyntaxKind.LockKeyword: 7410case SyntaxKind.ReturnKeyword: 7412case SyntaxKind.SwitchKeyword: 7413case SyntaxKind.CaseKeyword: // error recovery case. 7415case SyntaxKind.ThrowKeyword: 7417case SyntaxKind.UnsafeKeyword: 7422case SyntaxKind.UsingKeyword: 7424case SyntaxKind.WhileKeyword: 7426case SyntaxKind.OpenBraceToken: 7428case SyntaxKind.SemicolonToken: 7430case SyntaxKind.IdentifierToken: 7471bool beginsWithAwait = this.CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword; 7507if (this.CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword && 7508this.PeekToken(1).Kind == SyntaxKind.ForEachKeyword) 7510return this.ParseForEachStatement(attributes, this.EatContextualToken(SyntaxKind.AwaitKeyword)); 7514if (PeekToken(2).Kind == SyntaxKind.OpenParenToken) 7517return this.ParseUsingStatement(attributes, this.EatContextualToken(SyntaxKind.AwaitKeyword)); 7541=> PeekToken(1).Kind == SyntaxKind.OpenParenToken ? ParseUsingStatement(attributes) : ParseLocalDeclarationStatement(attributes); 7548=> CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword && PeekToken(1).Kind == SyntaxKind.UsingKeyword; 7552return this.PeekToken(1).Kind == SyntaxKind.ColonToken && this.IsTrueIdentifier(); 7557return this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken; 7562return this.CurrentToken.ContextualKind == SyntaxKind.YieldKeyword && 7563this.PeekToken(1).Kind is SyntaxKind.ReturnKeyword or SyntaxKind.BreakKeyword; 7572var tk = this.CurrentToken.Kind; 7573if (tk == SyntaxKind.RefKeyword || 7576this.PeekToken(1).Kind is not SyntaxKind.DotToken // e.g. `int.Parse()` is an expression 7577and not SyntaxKind.OpenParenToken)) // e.g. `int (x, y)` is an error decl expression 7583if (tk == SyntaxKind.UsingKeyword) 7585Debug.Assert(PeekToken(1).Kind != SyntaxKind.OpenParenToken); 7591Debug.Assert(PeekToken(2).Kind != SyntaxKind.OpenParenToken); 7602var isPossibleAttributeOrModifier = (IsAdditionalLocalFunctionModifier(tk) || tk == SyntaxKind.OpenBracketToken) 7603&& (tk is not (SyntaxKind.AsyncKeyword or SyntaxKind.ScopedKeyword) || ShouldContextualKeywordBeTreatedAsModifier(parsingStatementNotDeclaration: true)); 7641var tk = this.CurrentToken.ContextualKind; 7643if (tk == SyntaxKind.IdentifierToken) 7646if (token1.Kind == SyntaxKind.DotToken && 7647token1.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia)) 7649if (PeekToken(2).Kind == SyntaxKind.IdentifierToken && 7650PeekToken(3).Kind == SyntaxKind.IdentifierToken) 7665var token4Kind = PeekToken(4).Kind; 7666if (token4Kind != SyntaxKind.SemicolonToken && 7667token4Kind != SyntaxKind.EqualsToken && 7668token4Kind != SyntaxKind.CommaToken && 7669token4Kind != SyntaxKind.OpenParenToken && 7670token4Kind != SyntaxKind.LessThanToken) 7685if (st == ScanTypeFlags.MustBeType && this.CurrentToken.Kind is not SyntaxKind.DotToken and not SyntaxKind.OpenParenToken) 7690if (st == ScanTypeFlags.NotType || this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 7713if (this.CurrentToken.Kind != SyntaxKind.UsingKeyword) 7718var tk = PeekToken(1).Kind; 7720if (tk == SyntaxKind.RefKeyword) 7727if (tk != SyntaxKind.StaticKeyword) // For `static` we still need to make sure we have a typed identifier after it, because `using static type;` is a valid using directive. 7747if (tk == SyntaxKind.StaticKeyword) 7779if (this.CurrentToken.Kind is SyntaxKind.OpenBraceToken) 7785if (identifierOrThisOpt.Kind == SyntaxKind.ThisKeyword) 7800if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 7807if (this.CurrentToken.Kind == SyntaxKind.EqualsToken) 7816return this.CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.SemicolonToken; 7834if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken || this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 7841if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 7866if (parameter.Modifiers[i].Kind == SyntaxKind.ParamsKeyword) 7876if (parameter.Identifier.Kind == SyntaxKind.ArgListKeyword) 7881else if (parameter.Type.Kind == SyntaxKind.NullableType) 7901else if (parameter.Type.Kind == SyntaxKind.IdentifierName && 7902((IdentifierNameSyntax)parameter.Type).Identifier.ContextualKind == SyntaxKind.FromKeyword) 7925Debug.Assert(this.CurrentToken.Kind == SyntaxKind.NewKeyword); 7934case SyntaxKind.OpenBraceToken: 7935case SyntaxKind.OpenBracketToken: 7960if (SyntaxFacts.GetBaseTypeDeclarationKind(nextToken.Kind) != SyntaxKind.None) 8016case SyntaxKind.DotToken: 8017case SyntaxKind.AsteriskToken: 8018case SyntaxKind.QuestionToken: 8019case SyntaxKind.OpenBracketToken: 8020case SyntaxKind.LessThanToken: 8021case SyntaxKind.ColonColonToken: 8024case SyntaxKind.OpenParenToken: 8036case SyntaxKind.IdentifierToken: 8039case SyntaxKind.ThisKeyword: 8063this.CurrentNodeKind == SyntaxKind.Block && 8070CSharpSyntaxNode openBrace = isAccessorBody && this.CurrentToken.Kind != SyntaxKind.OpenBraceToken 8072SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken), 8076: this.EatToken(SyntaxKind.OpenBraceToken); 8088this.EatToken(SyntaxKind.CloseBraceToken)); 8104if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.Block && attributes.Count == 0) 8107CSharpSyntaxNode openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 8116this.EatToken(SyntaxKind.CloseBraceToken)); 8151while (this.CurrentToken.Kind is not SyntaxKind.CloseBraceToken and not SyntaxKind.EndOfFileToken 8166var action = this.SkipBadStatementListTokens(statements, SyntaxKind.CloseBraceToken, out trailingTrivia); 8183return this.CurrentToken.Kind == SyntaxKind.SemicolonToken 8187private PostSkipAction SkipBadStatementListTokens(SyntaxListBuilder<StatementSyntax> statements, SyntaxKind expected, out GreenNode trailingTrivia) 8195static (p, _) => p.CurrentToken.Kind == SyntaxKind.CloseBraceToken, 8197closeKind: SyntaxKind.None, 8203var tk = this.CurrentToken.Kind; 8206case SyntaxKind.FixedKeyword: 8207case SyntaxKind.BreakKeyword: 8208case SyntaxKind.ContinueKeyword: 8209case SyntaxKind.TryKeyword: 8210case SyntaxKind.CheckedKeyword: 8211case SyntaxKind.UncheckedKeyword: 8212case SyntaxKind.ConstKeyword: 8213case SyntaxKind.DoKeyword: 8214case SyntaxKind.ForKeyword: 8215case SyntaxKind.ForEachKeyword: 8216case SyntaxKind.GotoKeyword: 8217case SyntaxKind.IfKeyword: 8218case SyntaxKind.ElseKeyword: 8219case SyntaxKind.LockKeyword: 8220case SyntaxKind.ReturnKeyword: 8221case SyntaxKind.SwitchKeyword: 8222case SyntaxKind.ThrowKeyword: 8223case SyntaxKind.UnsafeKeyword: 8224case SyntaxKind.UsingKeyword: 8225case SyntaxKind.WhileKeyword: 8226case SyntaxKind.OpenBraceToken: 8227case SyntaxKind.SemicolonToken: 8228case SyntaxKind.StaticKeyword: 8229case SyntaxKind.ReadOnlyKeyword: 8230case SyntaxKind.VolatileKeyword: 8231case SyntaxKind.RefKeyword: 8232case SyntaxKind.ExternKeyword: 8233case SyntaxKind.OpenBracketToken: 8234case SyntaxKind.CaseKeyword: // for parsing an errant case without a switch. 8237case SyntaxKind.IdentifierToken: 8243case SyntaxKind.PublicKeyword: 8244case SyntaxKind.InternalKeyword: 8245case SyntaxKind.ProtectedKeyword: 8246case SyntaxKind.PrivateKeyword: 8256var @fixed = this.EatToken(SyntaxKind.FixedKeyword); 8257var openParen = this.EatToken(SyntaxKind.OpenParenToken); 8269this.EatToken(SyntaxKind.CloseParenToken), 8275return this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.OpenBraceToken or SyntaxKind.SemicolonToken; 8295return SyntaxFactory.EmptyStatement(attributeLists: default, EatToken(SyntaxKind.SemicolonToken)); 8301if (statement.Kind == SyntaxKind.ExpressionStatement && 8324this.EatToken(SyntaxKind.BreakKeyword), 8325this.EatToken(SyntaxKind.SemicolonToken)); 8332this.EatToken(SyntaxKind.ContinueKeyword), 8333this.EatToken(SyntaxKind.SemicolonToken)); 8338Debug.Assert(this.CurrentToken.Kind is SyntaxKind.TryKeyword or SyntaxKind.CatchKeyword or SyntaxKind.FinallyKeyword); 8341var @try = this.EatToken(SyntaxKind.TryKeyword); 8351Debug.Assert(this.CurrentToken.Kind is SyntaxKind.CatchKeyword or SyntaxKind.FinallyKeyword); 8365if (this.CurrentToken.Kind == SyntaxKind.CatchKeyword) 8368while (this.CurrentToken.Kind == SyntaxKind.CatchKeyword) 8374if (this.CurrentToken.Kind == SyntaxKind.FinallyKeyword) 8388SyntaxFactory.MissingToken(SyntaxKind.FinallyKeyword), 8402SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken), 8404SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)); 8409return this.CurrentToken.Kind is SyntaxKind.CloseBraceToken or SyntaxKind.CatchKeyword or SyntaxKind.FinallyKeyword; 8414Debug.Assert(this.CurrentToken.Kind == SyntaxKind.CatchKeyword); 8421if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 8435var closeParen = this.EatToken(SyntaxKind.CloseParenToken); 8441var keywordKind = this.CurrentToken.ContextualKind; 8442if (keywordKind == SyntaxKind.WhenKeyword || keywordKind == SyntaxKind.IfKeyword) 8444var whenKeyword = this.EatContextualToken(SyntaxKind.WhenKeyword); 8445if (keywordKind == SyntaxKind.IfKeyword) 8456var openParen = this.EatToken(SyntaxKind.OpenParenToken); 8460var closeParen = this.EatToken(SyntaxKind.CloseParenToken); 8473return this.CurrentToken.Kind is SyntaxKind.CloseParenToken 8474or SyntaxKind.OpenBraceToken 8475or SyntaxKind.CloseBraceToken 8476or SyntaxKind.CatchKeyword 8477or SyntaxKind.FinallyKeyword; 8482return this.CurrentToken.Kind is SyntaxKind.CloseParenToken 8483or SyntaxKind.OpenBraceToken 8484or SyntaxKind.CloseBraceToken 8485or SyntaxKind.CatchKeyword 8486or SyntaxKind.FinallyKeyword; 8490return this.CurrentToken.Kind is SyntaxKind.CloseBraceToken 8491or SyntaxKind.CatchKeyword 8492or SyntaxKind.FinallyKeyword; 8497Debug.Assert(this.CurrentToken.Kind is SyntaxKind.CheckedKeyword or SyntaxKind.UncheckedKeyword); 8499if (this.PeekToken(1).Kind == SyntaxKind.OpenParenToken) 8514Debug.Assert(this.CurrentToken.Kind == SyntaxKind.DoKeyword); 8515var @do = this.EatToken(SyntaxKind.DoKeyword); 8517var @while = this.EatToken(SyntaxKind.WhileKeyword); 8518var openParen = this.EatToken(SyntaxKind.OpenParenToken); 8532this.EatToken(SyntaxKind.CloseParenToken), 8533this.EatToken(SyntaxKind.SemicolonToken)); 8538return this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.SemicolonToken; 8555Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ForKeyword); 8557if (this.EatToken().Kind == SyntaxKind.OpenParenToken && 8559this.EatToken().Kind == SyntaxKind.IdentifierToken && 8560this.EatToken().Kind == SyntaxKind.InKeyword) 8576Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ForKeyword); 8578var forToken = this.EatToken(SyntaxKind.ForKeyword); 8579var openParen = this.EatToken(SyntaxKind.OpenParenToken); 8595if (this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword) 8597if (this.PeekToken(1).Kind == SyntaxKind.RefKeyword) 8604isDeclaration = ScanType() != ScanTypeFlags.NotType && this.CurrentToken.Kind == SyntaxKind.IdentifierToken; 8610else if (this.CurrentToken.Kind == SyntaxKind.RefKeyword) 8630scopedKeyword = EatContextualToken(SyntaxKind.ScopedKeyword); 8647else if (this.CurrentToken.Kind != SyntaxKind.SemicolonToken) 8653var semi = this.EatToken(SyntaxKind.SemicolonToken); 8655if (this.CurrentToken.Kind != SyntaxKind.SemicolonToken) 8660var semi2 = this.EatToken(SyntaxKind.SemicolonToken); 8661if (this.CurrentToken.Kind != SyntaxKind.CloseParenToken) 8676this.EatToken(SyntaxKind.CloseParenToken), 8688return this.CurrentToken.Kind is SyntaxKind.SemicolonToken or SyntaxKind.CloseParenToken or SyntaxKind.OpenBraceToken; 8695SyntaxKind.CloseParenToken, 8704LanguageParser @this, ref SyntaxToken startToken, SeparatedSyntaxListBuilder<ExpressionSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 8706if (@this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.SemicolonToken) 8710static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleExpression(), 8711static (p, closeKind) => p.CurrentToken.Kind == closeKind || p.CurrentToken.Kind == SyntaxKind.SemicolonToken, 8720Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ForEachKeyword || this.CurrentToken.Kind == SyntaxKind.ForKeyword); 8731if (this.CurrentToken.Kind == SyntaxKind.ForKeyword) 8734skippedForToken = this.AddError(skippedForToken, ErrorCode.ERR_SyntaxError, SyntaxFacts.GetText(SyntaxKind.ForEachKeyword)); 8735@foreach = ConvertToMissingWithTrailingTrivia(skippedForToken, SyntaxKind.ForEachKeyword); 8739@foreach = this.EatToken(SyntaxKind.ForEachKeyword); 8742var openParen = this.EatToken(SyntaxKind.OpenParenToken); 8745var @in = this.EatToken(SyntaxKind.InKeyword, ErrorCode.ERR_InExpected); 8752var closeParen = this.EatToken(SyntaxKind.CloseParenToken); 8757if (decl.designation.Kind != SyntaxKind.ParenthesizedVariableDesignation) 8763case SyntaxKind.SingleVariableDesignation: 8766case SyntaxKind.DiscardDesignation: 8769Debug.Assert(discard.Kind == SyntaxKind.UnderscoreToken); 8770identifier = SyntaxToken.WithValue(SyntaxKind.IdentifierToken, discard.LeadingTrivia.Node, discard.Text, discard.ValueText, discard.TrailingTrivia.Node); 8825if (this.IsInAsync && this.CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword) 8833if (this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword) 8836if (ScanType() != ScanTypeFlags.NotType && this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 8841if (this.PeekToken(1).Kind == SyntaxKind.CommaToken) 8849if (this.PeekToken(1).Kind is SyntaxKind.CommaToken or SyntaxKind.CloseParenToken) 8883return this.CurrentToken.Kind == SyntaxKind.CommaToken; 8885return this.CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.CloseParenToken; 8905case SyntaxKind.DotToken: 8906case SyntaxKind.ColonColonToken: 8907case SyntaxKind.OpenBracketToken: 8908case SyntaxKind.AsteriskToken: 8909case SyntaxKind.QuestionToken: 8910case SyntaxKind.LessThanToken: 8921case SyntaxKind.DeclarationExpression: 8924case SyntaxKind.TupleExpression: 8927case SyntaxKind.IdentifierName: 8929return ((IdentifierNameSyntax)variable).Identifier.ContextualKind == SyntaxKind.UnderscoreToken; 8937Debug.Assert(this.CurrentToken.Kind == SyntaxKind.GotoKeyword); 8939var @goto = this.EatToken(SyntaxKind.GotoKeyword); 8943SyntaxKind kind; 8945if (this.CurrentToken.Kind is SyntaxKind.CaseKeyword or SyntaxKind.DefaultKeyword) 8948if (caseOrDefault.Kind == SyntaxKind.CaseKeyword) 8950kind = SyntaxKind.GotoCaseStatement; 8955kind = SyntaxKind.GotoDefaultStatement; 8960kind = SyntaxKind.GotoStatement; 8965kind, attributes, @goto, caseOrDefault, arg, this.EatToken(SyntaxKind.SemicolonToken)); 8970Debug.Assert(this.CurrentToken.Kind == SyntaxKind.IfKeyword); 8974this.EatToken(SyntaxKind.IfKeyword), 8975this.EatToken(SyntaxKind.OpenParenToken), 8977this.EatToken(SyntaxKind.CloseParenToken), 8984Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ElseKeyword); 8988this.EatToken(SyntaxKind.IfKeyword, ErrorCode.ERR_ElseCannotStartStatement), 8989this.EatToken(SyntaxKind.OpenParenToken), 8991this.EatToken(SyntaxKind.CloseParenToken), 8998return this.CurrentToken.Kind != SyntaxKind.ElseKeyword 9001this.EatToken(SyntaxKind.ElseKeyword), 9007Debug.Assert(this.CurrentToken.Kind == SyntaxKind.LockKeyword); 9010this.EatToken(SyntaxKind.LockKeyword), 9011this.EatToken(SyntaxKind.OpenParenToken), 9013this.EatToken(SyntaxKind.CloseParenToken), 9019Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ReturnKeyword); 9022this.EatToken(SyntaxKind.ReturnKeyword), 9023this.CurrentToken.Kind != SyntaxKind.SemicolonToken ? this.ParsePossibleRefExpression() : null, 9024this.EatToken(SyntaxKind.SemicolonToken)); 9029Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.YieldKeyword); 9034SyntaxKind kind; 9036if (this.CurrentToken.Kind == SyntaxKind.BreakKeyword) 9038kind = SyntaxKind.YieldBreakStatement; 9043kind = SyntaxKind.YieldReturnStatement; 9044returnOrBreak = this.EatToken(SyntaxKind.ReturnKeyword); 9045if (this.CurrentToken.Kind == SyntaxKind.SemicolonToken) 9061this.EatToken(SyntaxKind.SemicolonToken)); 9066Debug.Assert(this.CurrentToken.Kind is SyntaxKind.SwitchKeyword or SyntaxKind.CaseKeyword); 9082this.EatToken(SyntaxKind.CloseBraceToken)); 9091if (this.CurrentToken.Kind is SyntaxKind.CaseKeyword) 9095switchKeyword = EatToken(SyntaxKind.SwitchKeyword); 9096openParen = SyntaxFactory.MissingToken(SyntaxKind.OpenParenToken); 9098closeParen = SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken); 9099openBrace = SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken); 9103switchKeyword = this.EatToken(SyntaxKind.SwitchKeyword); 9105if (expression.Kind == SyntaxKind.ParenthesizedExpression) 9114else if (expression.Kind == SyntaxKind.TupleExpression) 9124openParen = SyntaxFactory.MissingToken(SyntaxKind.OpenParenToken); 9126closeParen = SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken); 9129openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 9136return this.CurrentToken.Kind == SyntaxKind.CaseKeyword || 9137(this.CurrentToken.Kind == SyntaxKind.DefaultKeyword && this.PeekToken(1).Kind != SyntaxKind.OpenParenToken); 9151if (this.CurrentToken.Kind == SyntaxKind.CaseKeyword) 9155if (this.CurrentToken.Kind == SyntaxKind.ColonToken) 9160this.EatToken(SyntaxKind.ColonToken)); 9167if (this.CurrentToken.ContextualKind == SyntaxKind.WhenKeyword && node is ExpressionSyntax ex) 9170if (node.Kind == SyntaxKind.DiscardPattern) 9179this.EatToken(SyntaxKind.ColonToken)); 9186this.EatToken(SyntaxKind.ColonToken)); 9192Debug.Assert(this.CurrentToken.Kind == SyntaxKind.DefaultKeyword); 9194this.EatToken(SyntaxKind.DefaultKeyword), 9195this.EatToken(SyntaxKind.ColonToken)); 9214Debug.Assert(this.CurrentToken.Kind == SyntaxKind.ThrowKeyword); 9217this.EatToken(SyntaxKind.ThrowKeyword), 9218this.CurrentToken.Kind != SyntaxKind.SemicolonToken ? this.ParseExpressionCore() : null, 9219this.EatToken(SyntaxKind.SemicolonToken)); 9224Debug.Assert(this.CurrentToken.Kind == SyntaxKind.UnsafeKeyword); 9227this.EatToken(SyntaxKind.UnsafeKeyword), 9233var @using = this.EatToken(SyntaxKind.UsingKeyword); 9234var openParen = this.EatToken(SyntaxKind.OpenParenToken); 9250this.EatToken(SyntaxKind.CloseParenToken), 9293if (this.CurrentToken.Kind != SyntaxKind.IdentifierToken) 9307case SyntaxKind.CommaToken: 9308case SyntaxKind.CloseParenToken: 9313case SyntaxKind.EqualsToken: 9320if (this.CurrentToken.Kind == SyntaxKind.ColonToken && 9321declaration.Type.Kind == SyntaxKind.NullableType && 9352bool condition1 = st == ScanTypeFlags.MustBeType && this.CurrentToken.Kind != SyntaxKind.DotToken; 9353bool condition2 = st != ScanTypeFlags.NotType && this.CurrentToken.Kind == SyntaxKind.IdentifierToken; 9354bool condition3 = st == ScanTypeFlags.NonGenericTypeOrExpression || this.PeekToken(1).Kind == SyntaxKind.EqualsToken; 9361Debug.Assert(this.CurrentToken.Kind == SyntaxKind.WhileKeyword); 9364this.EatToken(SyntaxKind.WhileKeyword), 9365this.EatToken(SyntaxKind.OpenParenToken), 9367this.EatToken(SyntaxKind.CloseParenToken), 9375Debug.Assert(this.IsTrueIdentifier() && this.PeekToken(1).Kind == SyntaxKind.ColonToken); 9380this.EatToken(SyntaxKind.ColonToken), 9381this.ParsePossiblyAttributedStatement() ?? SyntaxFactory.EmptyStatement(attributeLists: default, EatToken(SyntaxKind.SemicolonToken))); 9393awaitKeyword = this.EatContextualToken(SyntaxKind.AwaitKeyword); 9396else if (this.CurrentToken.Kind == SyntaxKind.UsingKeyword) 9470this.EatToken(SyntaxKind.SemicolonToken)); 9480if (this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword) 9484SyntaxToken scopedKeyword = this.EatContextualToken(SyntaxKind.ScopedKeyword); 9486if (this.CurrentToken.Kind is not (SyntaxKind.RefKeyword or SyntaxKind.OutKeyword or SyntaxKind.InKeyword)) 9492? this.CurrentToken.Kind is not (SyntaxKind.CommaToken or SyntaxKind.GreaterThanToken) 9493: this.CurrentToken.Kind != SyntaxKind.IdentifierToken)) 9515if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 9517var openParen = this.EatToken(SyntaxKind.OpenParenToken); 9523done = (this.CurrentToken.Kind == SyntaxKind.CloseParenToken); 9528listOfDesignations.AddSeparator(EatToken(SyntaxKind.CommaToken)); 9536if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 9538listOfDesignations.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 9550this.EatToken(SyntaxKind.CloseParenToken)); 9566return CurrentToken.ContextualKind == SyntaxKind.UnderscoreToken 9567? _syntaxFactory.DiscardDesignation(this.EatContextualToken(SyntaxKind.UnderscoreToken)) 9568: _syntaxFactory.SingleVariableDesignation(this.EatToken(SyntaxKind.IdentifierToken)); 9573if (this.CurrentToken.ContextualKind != SyntaxKind.WhenKeyword) 9579this.EatContextualToken(SyntaxKind.WhenKeyword), 9610if (mods.Any((int)SyntaxKind.ConstKeyword)) 9628if (allowLocalFunctions && localFunction == null && type is PredefinedTypeSyntax { Keyword.Kind: SyntaxKind.VoidKeyword }) 9638case SyntaxKind.SemicolonToken: 9639case SyntaxKind.CloseParenToken: 9640case SyntaxKind.ColonToken: 9649SyntaxKind k; 9653if (k == SyntaxKind.AsyncKeyword) 9668if (k is SyntaxKind.ReadOnlyKeyword or SyntaxKind.VolatileKeyword) 9685Debug.Assert(this.CurrentToken.Kind == SyntaxKind.IdentifierToken); 9699if (ScanType() != ScanTypeFlags.NotType && this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 9713private static bool IsDeclarationModifier(SyntaxKind kind) 9717case SyntaxKind.ConstKeyword: 9718case SyntaxKind.StaticKeyword: 9719case SyntaxKind.ReadOnlyKeyword: 9720case SyntaxKind.VolatileKeyword: 9727private static bool IsAdditionalLocalFunctionModifier(SyntaxKind kind) 9731case SyntaxKind.StaticKeyword: 9732case SyntaxKind.AsyncKeyword: 9733case SyntaxKind.UnsafeKeyword: 9734case SyntaxKind.ExternKeyword: 9737case SyntaxKind.PublicKeyword: 9738case SyntaxKind.InternalKeyword: 9739case SyntaxKind.ProtectedKeyword: 9740case SyntaxKind.PrivateKeyword: 9748private static bool IsAccessibilityModifier(SyntaxKind kind) 9754case SyntaxKind.PublicKeyword: 9755case SyntaxKind.InternalKeyword: 9756case SyntaxKind.ProtectedKeyword: 9757case SyntaxKind.PrivateKeyword: 9783if (type.Kind == SyntaxKind.IdentifierName) 9786forceLocalFunc = id.ContextualKind != SyntaxKind.AwaitKeyword; 9797case SyntaxKind.AsyncKeyword: 9801case SyntaxKind.UnsafeKeyword: 9804case SyntaxKind.ReadOnlyKeyword: 9805case SyntaxKind.VolatileKeyword: 9807case SyntaxKind.StaticKeyword: 9809case SyntaxKind.ExternKeyword: 9848if (this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword) 9891if (IsScript && this.CurrentToken.Kind == SyntaxKind.EndOfFileToken) 9893semicolon = SyntaxFactory.MissingToken(SyntaxKind.SemicolonToken); 9899semicolon = this.EatToken(SyntaxKind.SemicolonToken); 9935SyntaxKind tk = this.CurrentToken.Kind; 9938case SyntaxKind.TypeOfKeyword: 9939case SyntaxKind.DefaultKeyword: 9940case SyntaxKind.SizeOfKeyword: 9941case SyntaxKind.MakeRefKeyword: 9942case SyntaxKind.RefTypeKeyword: 9943case SyntaxKind.CheckedKeyword: 9944case SyntaxKind.UncheckedKeyword: 9945case SyntaxKind.RefValueKeyword: 9946case SyntaxKind.ArgListKeyword: 9947case SyntaxKind.BaseKeyword: 9948case SyntaxKind.FalseKeyword: 9949case SyntaxKind.ThisKeyword: 9950case SyntaxKind.TrueKeyword: 9951case SyntaxKind.NullKeyword: 9952case SyntaxKind.OpenParenToken: 9953case SyntaxKind.NumericLiteralToken: 9954case SyntaxKind.StringLiteralToken: 9955case SyntaxKind.Utf8StringLiteralToken: 9956case SyntaxKind.SingleLineRawStringLiteralToken: 9957case SyntaxKind.Utf8SingleLineRawStringLiteralToken: 9958case SyntaxKind.MultiLineRawStringLiteralToken: 9959case SyntaxKind.Utf8MultiLineRawStringLiteralToken: 9960case SyntaxKind.InterpolatedStringToken: 9961case SyntaxKind.InterpolatedStringStartToken: 9962case SyntaxKind.InterpolatedVerbatimStringStartToken: 9963case SyntaxKind.InterpolatedSingleLineRawStringStartToken: 9964case SyntaxKind.InterpolatedMultiLineRawStringStartToken: 9965case SyntaxKind.CharacterLiteralToken: 9966case SyntaxKind.NewKeyword: 9967case SyntaxKind.DelegateKeyword: 9968case SyntaxKind.ColonColonToken: // bad aliased name 9969case SyntaxKind.ThrowKeyword: 9970case SyntaxKind.StackAllocKeyword: 9971case SyntaxKind.DotDotToken: 9972case SyntaxKind.RefKeyword: 9974case SyntaxKind.StaticKeyword: 9976case SyntaxKind.OpenBracketToken: 9978case SyntaxKind.IdentifierToken: 9981return this.IsTrueIdentifier() || this.CurrentToken.ContextualKind == SyntaxKind.FromKeyword; 9990private static bool IsInvalidSubExpression(SyntaxKind kind) 9994case SyntaxKind.BreakKeyword: 9995case SyntaxKind.CaseKeyword: 9996case SyntaxKind.CatchKeyword: 9997case SyntaxKind.ConstKeyword: 9998case SyntaxKind.ContinueKeyword: 9999case SyntaxKind.DoKeyword: 10000case SyntaxKind.FinallyKeyword: 10001case SyntaxKind.ForKeyword: 10002case SyntaxKind.ForEachKeyword: 10003case SyntaxKind.GotoKeyword: 10004case SyntaxKind.IfKeyword: 10005case SyntaxKind.ElseKeyword: 10006case SyntaxKind.LockKeyword: 10007case SyntaxKind.ReturnKeyword: 10008case SyntaxKind.SwitchKeyword: 10009case SyntaxKind.TryKeyword: 10010case SyntaxKind.UsingKeyword: 10011case SyntaxKind.WhileKeyword: 10018internal static bool IsRightAssociative(SyntaxKind op) 10022case SyntaxKind.SimpleAssignmentExpression: 10023case SyntaxKind.AddAssignmentExpression: 10024case SyntaxKind.SubtractAssignmentExpression: 10025case SyntaxKind.MultiplyAssignmentExpression: 10026case SyntaxKind.DivideAssignmentExpression: 10027case SyntaxKind.ModuloAssignmentExpression: 10028case SyntaxKind.AndAssignmentExpression: 10029case SyntaxKind.ExclusiveOrAssignmentExpression: 10030case SyntaxKind.OrAssignmentExpression: 10031case SyntaxKind.LeftShiftAssignmentExpression: 10032case SyntaxKind.RightShiftAssignmentExpression: 10033case SyntaxKind.UnsignedRightShiftAssignmentExpression: 10034case SyntaxKind.CoalesceAssignmentExpression: 10035case SyntaxKind.CoalesceExpression: 10068private static Precedence GetPrecedence(SyntaxKind op) 10072case SyntaxKind.QueryExpression: 10074case SyntaxKind.ParenthesizedLambdaExpression: 10075case SyntaxKind.SimpleLambdaExpression: 10076case SyntaxKind.AnonymousMethodExpression: 10078case SyntaxKind.SimpleAssignmentExpression: 10079case SyntaxKind.AddAssignmentExpression: 10080case SyntaxKind.SubtractAssignmentExpression: 10081case SyntaxKind.MultiplyAssignmentExpression: 10082case SyntaxKind.DivideAssignmentExpression: 10083case SyntaxKind.ModuloAssignmentExpression: 10084case SyntaxKind.AndAssignmentExpression: 10085case SyntaxKind.ExclusiveOrAssignmentExpression: 10086case SyntaxKind.OrAssignmentExpression: 10087case SyntaxKind.LeftShiftAssignmentExpression: 10088case SyntaxKind.RightShiftAssignmentExpression: 10089case SyntaxKind.UnsignedRightShiftAssignmentExpression: 10090case SyntaxKind.CoalesceAssignmentExpression: 10092case SyntaxKind.CoalesceExpression: 10093case SyntaxKind.ThrowExpression: 10095case SyntaxKind.LogicalOrExpression: 10097case SyntaxKind.LogicalAndExpression: 10099case SyntaxKind.BitwiseOrExpression: 10101case SyntaxKind.ExclusiveOrExpression: 10103case SyntaxKind.BitwiseAndExpression: 10105case SyntaxKind.EqualsExpression: 10106case SyntaxKind.NotEqualsExpression: 10108case SyntaxKind.LessThanExpression: 10109case SyntaxKind.LessThanOrEqualExpression: 10110case SyntaxKind.GreaterThanExpression: 10111case SyntaxKind.GreaterThanOrEqualExpression: 10112case SyntaxKind.IsExpression: 10113case SyntaxKind.AsExpression: 10114case SyntaxKind.IsPatternExpression: 10116case SyntaxKind.SwitchExpression: 10117case SyntaxKind.WithExpression: 10119case SyntaxKind.LeftShiftExpression: 10120case SyntaxKind.RightShiftExpression: 10121case SyntaxKind.UnsignedRightShiftExpression: 10123case SyntaxKind.AddExpression: 10124case SyntaxKind.SubtractExpression: 10126case SyntaxKind.MultiplyExpression: 10127case SyntaxKind.DivideExpression: 10128case SyntaxKind.ModuloExpression: 10130case SyntaxKind.UnaryPlusExpression: 10131case SyntaxKind.UnaryMinusExpression: 10132case SyntaxKind.BitwiseNotExpression: 10133case SyntaxKind.LogicalNotExpression: 10134case SyntaxKind.PreIncrementExpression: 10135case SyntaxKind.PreDecrementExpression: 10136case SyntaxKind.TypeOfExpression: 10137case SyntaxKind.SizeOfExpression: 10138case SyntaxKind.CheckedExpression: 10139case SyntaxKind.UncheckedExpression: 10140case SyntaxKind.MakeRefExpression: 10141case SyntaxKind.RefValueExpression: 10142case SyntaxKind.RefTypeExpression: 10143case SyntaxKind.AwaitExpression: 10144case SyntaxKind.IndexExpression: 10146case SyntaxKind.CastExpression: 10148case SyntaxKind.PointerIndirectionExpression: 10150case SyntaxKind.AddressOfExpression: 10152case SyntaxKind.RangeExpression: 10154case SyntaxKind.ConditionalExpression: 10156case SyntaxKind.AliasQualifiedName: 10157case SyntaxKind.AnonymousObjectCreationExpression: 10158case SyntaxKind.ArgListExpression: 10159case SyntaxKind.ArrayCreationExpression: 10160case SyntaxKind.BaseExpression: 10161case SyntaxKind.CharacterLiteralExpression: 10162case SyntaxKind.ConditionalAccessExpression: 10163case SyntaxKind.DeclarationExpression: 10164case SyntaxKind.DefaultExpression: 10165case SyntaxKind.DefaultLiteralExpression: 10166case SyntaxKind.ElementAccessExpression: 10167case SyntaxKind.FalseLiteralExpression: 10168case SyntaxKind.GenericName: 10169case SyntaxKind.IdentifierName: 10170case SyntaxKind.ImplicitArrayCreationExpression: 10171case SyntaxKind.ImplicitStackAllocArrayCreationExpression: 10172case SyntaxKind.ImplicitObjectCreationExpression: 10173case SyntaxKind.InterpolatedStringExpression: 10174case SyntaxKind.InvocationExpression: 10175case SyntaxKind.NullLiteralExpression: 10176case SyntaxKind.NumericLiteralExpression: 10177case SyntaxKind.ObjectCreationExpression: 10178case SyntaxKind.ParenthesizedExpression: 10179case SyntaxKind.PointerMemberAccessExpression: 10180case SyntaxKind.PostDecrementExpression: 10181case SyntaxKind.PostIncrementExpression: 10182case SyntaxKind.PredefinedType: 10183case SyntaxKind.RefExpression: 10184case SyntaxKind.SimpleMemberAccessExpression: 10185case SyntaxKind.StackAllocArrayCreationExpression: 10186case SyntaxKind.StringLiteralExpression: 10187case SyntaxKind.Utf8StringLiteralExpression: 10188case SyntaxKind.SuppressNullableWarningExpression: 10189case SyntaxKind.ThisExpression: 10190case SyntaxKind.TrueLiteralExpression: 10191case SyntaxKind.TupleExpression: 10198private static bool IsExpectedPrefixUnaryOperator(SyntaxKind kind) 10200return SyntaxFacts.IsPrefixUnaryExpression(kind) && kind is not SyntaxKind.RefKeyword and not SyntaxKind.OutKeyword; 10203private static bool IsExpectedBinaryOperator(SyntaxKind kind) 10208private static bool IsExpectedAssignmentOperator(SyntaxKind kind) 10215return (this.IsScript || this.IsInAsync) && this.CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword; 10220if (this.CurrentToken.ContextualKind == SyntaxKind.AwaitKeyword) 10234case SyntaxKind.IdentifierToken: 10235return next.ContextualKind != SyntaxKind.WithKeyword; 10238case SyntaxKind.NewKeyword: 10239case SyntaxKind.ThisKeyword: 10240case SyntaxKind.BaseKeyword: 10241case SyntaxKind.DelegateKeyword: 10242case SyntaxKind.TypeOfKeyword: 10243case SyntaxKind.CheckedKeyword: 10244case SyntaxKind.UncheckedKeyword: 10245case SyntaxKind.DefaultKeyword: 10248case SyntaxKind.TrueKeyword: 10249case SyntaxKind.FalseKeyword: 10250case SyntaxKind.StringLiteralToken: 10251case SyntaxKind.SingleLineRawStringLiteralToken: 10252case SyntaxKind.Utf8SingleLineRawStringLiteralToken: 10253case SyntaxKind.MultiLineRawStringLiteralToken: 10254case SyntaxKind.Utf8MultiLineRawStringLiteralToken: 10255case SyntaxKind.InterpolatedStringToken: 10256case SyntaxKind.Utf8StringLiteralToken: 10257case SyntaxKind.InterpolatedStringStartToken: 10258case SyntaxKind.InterpolatedVerbatimStringStartToken: 10259case SyntaxKind.InterpolatedSingleLineRawStringStartToken: 10260case SyntaxKind.InterpolatedMultiLineRawStringStartToken: 10261case SyntaxKind.NumericLiteralToken: 10262case SyntaxKind.NullKeyword: 10263case SyntaxKind.CharacterLiteralToken: 10301var tk = this.CurrentToken.Kind; 10310var opKind = SyntaxFacts.GetPrefixUnaryExpression(tk); 10316else if (tk == SyntaxKind.DotDotToken) 10320newPrecedence = GetPrecedence(SyntaxKind.RangeExpression); 10336newPrecedence = GetPrecedence(SyntaxKind.AwaitExpression); 10338this.EatContextualToken(SyntaxKind.AwaitKeyword), 10345else if (this.CurrentToken.ContextualKind == SyntaxKind.FromKeyword && IsInQuery) 10354else if (tk == SyntaxKind.ThrowKeyword) 10379var tk = this.CurrentToken.ContextualKind; 10382SyntaxKind opKind; 10392else if (tk == SyntaxKind.DotDotToken) 10394opKind = SyntaxKind.RangeExpression; 10396else if (tk == SyntaxKind.SwitchKeyword && this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken) 10398opKind = SyntaxKind.SwitchExpression; 10400else if (tk == SyntaxKind.WithKeyword && this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken) 10402opKind = SyntaxKind.WithExpression; 10413if (tk == SyntaxKind.GreaterThanToken 10414&& this.PeekToken(1).Kind is SyntaxKind.GreaterThanToken or SyntaxKind.GreaterThanEqualsToken 10417if (this.PeekToken(1).Kind == SyntaxKind.GreaterThanToken) 10419if (this.PeekToken(2).Kind is SyntaxKind.GreaterThanToken or SyntaxKind.GreaterThanEqualsToken 10422if (this.PeekToken(2).Kind == SyntaxKind.GreaterThanToken) 10424opKind = SyntaxFacts.GetBinaryExpression(SyntaxKind.GreaterThanGreaterThanGreaterThanToken); 10428opKind = SyntaxFacts.GetAssignmentExpression(SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken); 10436opKind = SyntaxFacts.GetBinaryExpression(SyntaxKind.GreaterThanGreaterThanToken); 10442opKind = SyntaxFacts.GetAssignmentExpression(SyntaxKind.GreaterThanGreaterThanEqualsToken); 10479ErrorCode errorCode = leftOperand.Kind == SyntaxKind.IsPatternExpression ? ErrorCode.ERR_UnexpectedToken : ErrorCode.WRN_PrecedenceInversion; 10487var kind = opToken2.Kind == SyntaxKind.GreaterThanToken ? SyntaxKind.GreaterThanGreaterThanToken : SyntaxKind.GreaterThanGreaterThanEqualsToken; 10493Debug.Assert(opToken2.Kind == SyntaxKind.GreaterThanToken); 10495var kind = opToken2.Kind == SyntaxKind.GreaterThanToken ? SyntaxKind.GreaterThanGreaterThanGreaterThanToken : SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken; 10503if (opKind == SyntaxKind.AsExpression) 10508else if (opKind == SyntaxKind.IsExpression) 10516if (opKind == SyntaxKind.SimpleAssignmentExpression && CurrentToken.Kind == SyntaxKind.RefKeyword && 10531else if (opKind == SyntaxKind.SwitchExpression) 10535else if (opKind == SyntaxKind.WithExpression) 10539else if (tk == SyntaxKind.DotDotToken) 10542Debug.Assert(opKind == SyntaxKind.RangeExpression); 10571if (CurrentToken.Kind == SyntaxKind.QuestionToken && precedence <= Precedence.Conditional) 10575if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken && this.lexer.InterpolationFollowedByColon) 10581var colon = SyntaxFactory.MissingToken(SyntaxKind.ColonToken); 10582var colonRight = _syntaxFactory.IdentifierName(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)); 10588var colon = this.EatToken(SyntaxKind.ColonToken); 10600? EatContextualToken(SyntaxKind.ScopedKeyword) 10612this.EatToken(SyntaxKind.ThrowKeyword), 10622TypeSyntax type => _syntaxFactory.BinaryExpression(SyntaxKind.IsExpression, leftOperand, opToken, type), 10632var tk = this.CurrentToken.Kind; 10635case SyntaxKind.TypeOfKeyword: 10637case SyntaxKind.DefaultKeyword: 10639case SyntaxKind.SizeOfKeyword: 10641case SyntaxKind.MakeRefKeyword: 10643case SyntaxKind.RefTypeKeyword: 10645case SyntaxKind.CheckedKeyword: 10646case SyntaxKind.UncheckedKeyword: 10648case SyntaxKind.RefValueKeyword: 10650case SyntaxKind.ColonColonToken: 10655case SyntaxKind.EqualsGreaterThanToken: 10657case SyntaxKind.StaticKeyword: 10670case SyntaxKind.IdentifierToken: 10696case SyntaxKind.OpenBracketToken: 10702case SyntaxKind.ThisKeyword: 10704case SyntaxKind.BaseKeyword: 10707case SyntaxKind.ArgListKeyword: 10708case SyntaxKind.FalseKeyword: 10709case SyntaxKind.TrueKeyword: 10710case SyntaxKind.NullKeyword: 10711case SyntaxKind.NumericLiteralToken: 10712case SyntaxKind.StringLiteralToken: 10713case SyntaxKind.Utf8StringLiteralToken: 10714case SyntaxKind.SingleLineRawStringLiteralToken: 10715case SyntaxKind.Utf8SingleLineRawStringLiteralToken: 10716case SyntaxKind.MultiLineRawStringLiteralToken: 10717case SyntaxKind.Utf8MultiLineRawStringLiteralToken: 10718case SyntaxKind.CharacterLiteralToken: 10720case SyntaxKind.InterpolatedStringStartToken: 10721case SyntaxKind.InterpolatedVerbatimStringStartToken: 10722case SyntaxKind.InterpolatedSingleLineRawStringStartToken: 10723case SyntaxKind.InterpolatedMultiLineRawStringStartToken: 10725case SyntaxKind.InterpolatedStringToken: 10727case SyntaxKind.OpenParenToken: 10733case SyntaxKind.NewKeyword: 10735case SyntaxKind.StackAllocKeyword: 10737case SyntaxKind.DelegateKeyword: 10742case SyntaxKind.RefKeyword: 10762if (this.CurrentToken.Kind != SyntaxKind.DotToken || tk == SyntaxKind.VoidKeyword) 10773if (tk == SyntaxKind.EndOfFileToken) 10789Debug.Assert(this.CurrentToken.Kind == SyntaxKind.BaseKeyword); 10812this.CurrentToken.Kind == SyntaxKind.OpenParenToken && ScanDesignator() && 10813this.CurrentToken.Kind == SyntaxKind.EqualsToken; 10820case SyntaxKind.IdentifierToken: 10828case SyntaxKind.OpenParenToken: 10839case SyntaxKind.CommaToken: 10841case SyntaxKind.CloseParenToken: 10857while (this.PeekToken(tokenIndex).Kind == SyntaxKind.StaticKeyword || 10858this.PeekToken(tokenIndex).ContextualKind == SyntaxKind.AsyncKeyword) 10863return this.PeekToken(tokenIndex).Kind == SyntaxKind.DelegateKeyword && 10864this.PeekToken(tokenIndex + 1).Kind != SyntaxKind.AsteriskToken; 10875case SyntaxKind.OpenParenToken: 10879case SyntaxKind.OpenBracketToken: 10883case SyntaxKind.PlusPlusToken: 10884case SyntaxKind.MinusMinusToken: 10888case SyntaxKind.ColonColonToken: 10889if (this.PeekToken(1).Kind == SyntaxKind.IdentifierToken) 10892SyntaxKind.SimpleMemberAccessExpression, 10895this.ConvertToMissingWithTrailingTrivia(this.AddError(this.EatToken(), ErrorCode.ERR_UnexpectedAliasedName), SyntaxKind.DotToken), 10901expr = AddTrailingSkippedSyntax(expr, this.EatTokenWithPrejudice(SyntaxKind.DotToken)); 10906case SyntaxKind.MinusGreaterThanToken: 10907expr = _syntaxFactory.MemberAccessExpression(SyntaxKind.PointerMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)); 10910case SyntaxKind.DotToken: 10920if (this.CurrentToken.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia) && 10921this.PeekToken(1).Kind == SyntaxKind.IdentifierToken && 10922this.PeekToken(2).ContextualKind == SyntaxKind.IdentifierToken) 10925SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), 10929expr = _syntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)); 10932case SyntaxKind.QuestionToken: 10944case SyntaxKind.ExclamationToken: 10945expr = _syntaxFactory.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, this.EatToken()); 10954private static bool CanStartConsequenceExpression(SyntaxKind kind) 10956return kind is SyntaxKind.DotToken or SyntaxKind.OpenBracketToken; 10964SyntaxKind.DotToken => _syntaxFactory.MemberBindingExpression(this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)), 10965SyntaxKind.OpenBracketToken => _syntaxFactory.ElementBindingExpression(this.ParseBracketedArgumentList()), 10975while (this.CurrentToken.Kind == SyntaxKind.ExclamationToken) 10976expr = _syntaxFactory.PostfixUnaryExpression(SyntaxKind.SuppressNullableWarningExpression, expr, EatToken()); 10981case SyntaxKind.OpenParenToken: 10985case SyntaxKind.OpenBracketToken: 10989case SyntaxKind.DotToken: 10990expr = _syntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, expr, this.EatToken(), this.ParseSimpleName(NameOptions.InExpression)); 10993case SyntaxKind.QuestionToken: 11009while (this.PeekToken(index).Kind == SyntaxKind.ExclamationToken) 11013is SyntaxKind.OpenParenToken 11014or SyntaxKind.OpenBracketToken 11015or SyntaxKind.DotToken 11016or SyntaxKind.QuestionToken; 11022if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.ArgumentList) 11031openKind: SyntaxKind.OpenParenToken, 11032closeKind: SyntaxKind.CloseParenToken); 11038if (this.IsIncrementalAndFactoryContextMatches && this.CurrentNodeKind == SyntaxKind.BracketedArgumentList) 11047openKind: SyntaxKind.OpenBracketToken, 11048closeKind: SyntaxKind.CloseBracketToken); 11056SyntaxKind openKind, 11057SyntaxKind closeKind) 11059Debug.Assert(openKind is SyntaxKind.OpenParenToken or SyntaxKind.OpenBracketToken); 11060Debug.Assert(closeKind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken); 11061Debug.Assert((openKind == SyntaxKind.OpenParenToken) == (closeKind == SyntaxKind.CloseParenToken)); 11062bool isIndexer = openKind == SyntaxKind.OpenBracketToken; 11065openToken = this.CurrentToken.Kind is SyntaxKind.OpenParenToken or SyntaxKind.OpenBracketToken 11072if (this.CurrentToken.Kind != closeKind && this.CurrentToken.Kind != SyntaxKind.SemicolonToken) 11079SyntaxKind.CloseBracketToken, 11091SyntaxKind.CloseParenToken, 11116closeToken = this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken 11123LanguageParser @this, ref SyntaxToken open, SeparatedSyntaxListBuilder<ArgumentSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 11125if (@this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken or SyntaxKind.SemicolonToken) 11129static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleArgumentExpression(), 11130static (p, closeKind) => p.CurrentToken.Kind == closeKind || p.CurrentToken.Kind == SyntaxKind.SemicolonToken, 11137return this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.CloseBracketToken; 11145private static bool IsValidArgumentRefKindKeyword(SyntaxKind kind) 11149case SyntaxKind.RefKeyword: 11150case SyntaxKind.OutKeyword: 11151case SyntaxKind.InKeyword: 11160var nameColon = this.CurrentToken.Kind == SyntaxKind.IdentifierToken && this.PeekToken(1).Kind == SyntaxKind.ColonToken 11163this.EatToken(SyntaxKind.ColonToken)) 11169!(this.CurrentToken.Kind == SyntaxKind.RefKeyword && 11177if (isIndexer && this.CurrentToken.Kind is SyntaxKind.CommaToken or SyntaxKind.CloseBracketToken) 11181else if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 11193expression = refKindKeyword?.Kind == SyntaxKind.OutKeyword 11205this.EatToken(SyntaxKind.OpenParenToken), 11207this.EatToken(SyntaxKind.CloseParenToken)); 11213if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 11217this.EatToken(SyntaxKind.OpenParenToken), 11219this.EatToken(SyntaxKind.CloseParenToken)); 11223return _syntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression, keyword); 11231this.EatToken(SyntaxKind.OpenParenToken), 11233this.EatToken(SyntaxKind.CloseParenToken)); 11240this.EatToken(SyntaxKind.OpenParenToken), 11242this.EatToken(SyntaxKind.CloseParenToken)); 11249this.EatToken(SyntaxKind.OpenParenToken), 11251this.EatToken(SyntaxKind.CloseParenToken)); 11257Debug.Assert(checkedOrUnchecked.Kind is SyntaxKind.CheckedKeyword or SyntaxKind.UncheckedKeyword); 11258var kind = checkedOrUnchecked.Kind == SyntaxKind.CheckedKeyword ? SyntaxKind.CheckedExpression : SyntaxKind.UncheckedExpression; 11263this.EatToken(SyntaxKind.OpenParenToken), 11265this.EatToken(SyntaxKind.CloseParenToken)); 11271this.EatToken(SyntaxKind.RefValueKeyword), 11272this.EatToken(SyntaxKind.OpenParenToken), 11274this.EatToken(SyntaxKind.CommaToken), 11276this.EatToken(SyntaxKind.CloseParenToken)); 11286Debug.Assert(CurrentToken.Kind == SyntaxKind.OpenParenToken); 11302if (tk.Kind is not SyntaxKind.IdentifierToken and not SyntaxKind.CommaToken 11311return this.PeekToken(curTk - 1).Kind == SyntaxKind.CloseParenToken && 11312this.PeekToken(curTk).Kind == SyntaxKind.EqualsGreaterThanToken; 11320if (PeekToken(skipIndex).Kind == SyntaxKind.ExclamationToken 11321&& this.PeekToken(skipIndex + 1).Kind == SyntaxKind.ExclamationToken) 11327if (this.PeekToken(skipIndex).Kind == SyntaxKind.CloseParenToken 11328&& this.PeekToken(skipIndex + 1).Kind == SyntaxKind.EqualsGreaterThanToken) 11335if (this.PeekToken(1).Kind == SyntaxKind.CloseParenToken 11336&& this.PeekToken(2).Kind == SyntaxKind.EqualsGreaterThanToken) 11344if (this.PeekToken(1).Kind == SyntaxKind.ParamsKeyword) 11356if (token1.Kind == SyntaxKind.IdentifierToken) 11363if (token2.Kind == SyntaxKind.CommaToken) 11371if (token2.Kind == SyntaxKind.ExclamationToken 11372&& token3.Kind == SyntaxKind.ExclamationToken 11373&& this.PeekToken(4).Kind == SyntaxKind.CommaToken) 11385Debug.Assert(CurrentToken.Kind == SyntaxKind.OpenParenToken); 11412if (IsParameterModifierExcludingScoped(this.CurrentToken) || this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword) 11433equalsToken ??= TryEatToken(SyntaxKind.EqualsToken); 11442case SyntaxKind.CommaToken: 11445case SyntaxKind.CloseParenToken: 11446return this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken; 11456Debug.Assert(this.CurrentToken.Kind == SyntaxKind.OpenParenToken); 11471this.EatToken(SyntaxKind.OpenParenToken), 11473this.EatToken(SyntaxKind.CloseParenToken), 11480var openParen = this.EatToken(SyntaxKind.OpenParenToken); 11484if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 11492if (expression.Kind == SyntaxKind.IdentifierName && this.CurrentToken.Kind == SyntaxKind.ColonToken) 11505this.EatToken(SyntaxKind.CloseParenToken)); 11513while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 11515list.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 11518var argument = expression.Kind != SyntaxKind.IdentifierName || this.CurrentToken.Kind != SyntaxKind.ColonToken 11530list.AddSeparator(SyntaxFactory.MissingToken(SyntaxKind.CommaToken)); 11539this.EatToken(SyntaxKind.CloseParenToken)); 11544if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 11557if (this.CurrentToken.Kind != SyntaxKind.CloseParenToken) 11564if (forPattern && this.CurrentToken.Kind == SyntaxKind.IdentifierToken) 11588SyntaxKind.PlusToken or 11589SyntaxKind.MinusToken or 11590SyntaxKind.AmpersandToken or 11591SyntaxKind.AsteriskToken or 11592SyntaxKind.DotDotToken => true, 11634return this.CurrentToken.ContextualKind is SyntaxKind.OrKeyword or SyntaxKind.AndKeyword; 11655if (token1.Kind == SyntaxKind.EqualsGreaterThanToken) 11668(SyntaxKind.ExclamationToken, SyntaxKind.ExclamationToken, SyntaxKind.EqualsGreaterThanToken) 11671or (SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken, _) 11674or (SyntaxKind.ExclamationToken, SyntaxKind.ExclamationEqualsToken, SyntaxKind.GreaterThanToken)) 11681if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) 11687if (this.CurrentToken.Kind == SyntaxKind.StaticKeyword) 11692else if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword && 11693this.PeekToken(1).Kind == SyntaxKind.StaticKeyword) 11706if (this.CurrentToken.Kind == SyntaxKind.EqualsGreaterThanToken) 11716if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 11724if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && 11725this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken) 11735if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword && 11744if (st == ScanTypeFlags.NotType || this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 11761if (this.CurrentToken.Kind == SyntaxKind.IdentifierToken && 11762this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken) 11769if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 11778private static bool CanFollowCast(SyntaxKind kind) 11782case SyntaxKind.AsKeyword: 11783case SyntaxKind.IsKeyword: 11784case SyntaxKind.SemicolonToken: 11785case SyntaxKind.CloseParenToken: 11786case SyntaxKind.CloseBracketToken: 11787case SyntaxKind.OpenBraceToken: 11788case SyntaxKind.CloseBraceToken: 11789case SyntaxKind.CommaToken: 11790case SyntaxKind.EqualsToken: 11791case SyntaxKind.PlusEqualsToken: 11792case SyntaxKind.MinusEqualsToken: 11793case SyntaxKind.AsteriskEqualsToken: 11794case SyntaxKind.SlashEqualsToken: 11795case SyntaxKind.PercentEqualsToken: 11796case SyntaxKind.AmpersandEqualsToken: 11797case SyntaxKind.CaretEqualsToken: 11798case SyntaxKind.BarEqualsToken: 11799case SyntaxKind.LessThanLessThanEqualsToken: 11800case SyntaxKind.GreaterThanGreaterThanEqualsToken: 11801case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: 11802case SyntaxKind.QuestionToken: 11803case SyntaxKind.ColonToken: 11804case SyntaxKind.BarBarToken: 11805case SyntaxKind.AmpersandAmpersandToken: 11806case SyntaxKind.BarToken: 11807case SyntaxKind.CaretToken: 11808case SyntaxKind.AmpersandToken: 11809case SyntaxKind.EqualsEqualsToken: 11810case SyntaxKind.ExclamationEqualsToken: 11811case SyntaxKind.LessThanToken: 11812case SyntaxKind.LessThanEqualsToken: 11813case SyntaxKind.GreaterThanToken: 11814case SyntaxKind.GreaterThanEqualsToken: 11815case SyntaxKind.QuestionQuestionEqualsToken: 11816case SyntaxKind.LessThanLessThanToken: 11817case SyntaxKind.GreaterThanGreaterThanToken: 11818case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: 11819case SyntaxKind.PlusToken: 11820case SyntaxKind.MinusToken: 11821case SyntaxKind.AsteriskToken: 11822case SyntaxKind.SlashToken: 11823case SyntaxKind.PercentToken: 11824case SyntaxKind.PlusPlusToken: 11825case SyntaxKind.MinusMinusToken: 11826case SyntaxKind.OpenBracketToken: 11827case SyntaxKind.DotToken: 11828case SyntaxKind.MinusGreaterThanToken: 11829case SyntaxKind.QuestionQuestionToken: 11830case SyntaxKind.EndOfFileToken: 11831case SyntaxKind.SwitchKeyword: 11832case SyntaxKind.EqualsGreaterThanToken: 11833case SyntaxKind.DotDotToken: 11842Debug.Assert(this.CurrentToken.Kind == SyntaxKind.NewKeyword); 11861return this.CurrentToken.Kind == SyntaxKind.NewKeyword && this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken; 11867var @new = this.EatToken(SyntaxKind.NewKeyword); 11869Debug.Assert(this.CurrentToken.Kind == SyntaxKind.OpenBraceToken); 11871var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 11874SyntaxKind.CloseBraceToken, 11886this.EatToken(SyntaxKind.CloseBraceToken)); 11906return this.CurrentToken.Kind == SyntaxKind.OpenBraceToken; 11911return IsTrueIdentifier() && this.PeekToken(1).Kind == SyntaxKind.EqualsToken; 11916return this.CurrentToken.Kind == SyntaxKind.OpenBracketToken; 11921SyntaxToken @new = this.EatToken(SyntaxKind.NewKeyword); 11929if (type.Kind == SyntaxKind.ArrayType) 11932if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken) 11942if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 11947if (this.CurrentToken.Kind == SyntaxKind.OpenBraceToken) 11956this.EatToken(SyntaxKind.OpenParenToken, ErrorCode.ERR_BadNewExpr, reportError: type?.ContainsDiagnostics == false), 11958SyntaxFactory.MissingToken(SyntaxKind.CloseParenToken)); 11969if (this.CurrentToken.Kind != SyntaxKind.OpenParenToken) 11982case SyntaxKind.QuestionToken: // e.g. `new(a, b)?()` 11983case SyntaxKind.OpenBracketToken: // e.g. `new(a, b)[]` 11984case SyntaxKind.OpenParenToken: // e.g. `new(a, b)()` for better error recovery 11996var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 11999SyntaxKind.CloseBraceToken, 12011SyntaxKind.WithInitializerExpression, 12014this.EatToken(SyntaxKind.CloseBraceToken))); 12021var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 12025SyntaxKind.CloseBraceToken, 12033var kind = isObjectInitializer(initializers) ? SyntaxKind.ObjectInitializerExpression : SyntaxKind.CollectionInitializerExpression; 12039this.EatToken(SyntaxKind.CloseBraceToken)); 12053Kind: SyntaxKind.SimpleAssignmentExpression, 12054Left.Kind: SyntaxKind.IdentifierName or SyntaxKind.ImplicitElementAccess, 12095LanguageParser @this, ref SyntaxToken startToken, SeparatedSyntaxListBuilder<T> list, SyntaxKind expectedKind, SyntaxKind closeKind) 12099static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleExpression(), 12107SyntaxKind.SimpleAssignmentExpression, 12109this.EatToken(SyntaxKind.EqualsToken), 12110this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 12118SyntaxKind.SimpleAssignmentExpression, 12120this.EatToken(SyntaxKind.EqualsToken), 12121this.CurrentToken.Kind == SyntaxKind.OpenBraceToken 12128var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 12132SyntaxKind.CloseBraceToken, 12141SyntaxKind.ComplexElementInitializerExpression, 12144this.EatToken(SyntaxKind.CloseBraceToken)); 12149Debug.Assert(this.CurrentToken.Kind is SyntaxKind.NewKeyword or SyntaxKind.StackAllocKeyword); 12150return this.PeekToken(1).Kind == SyntaxKind.OpenBracketToken; 12155var @new = this.EatToken(SyntaxKind.NewKeyword); 12156var openBracket = this.EatToken(SyntaxKind.OpenBracketToken); 12176if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 12189this.EatToken(SyntaxKind.CloseBracketToken), 12195var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 12198SyntaxKind.CloseBraceToken, 12207SyntaxKind.ArrayInitializerExpression, 12210this.EatToken(SyntaxKind.CloseBraceToken)); 12213LanguageParser @this, ref SyntaxToken openBrace, SeparatedSyntaxListBuilder<ExpressionSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 12216static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleVariableInitializer(), 12231var @stackalloc = this.EatToken(SyntaxKind.StackAllocKeyword); 12232var openBracket = this.EatToken(SyntaxKind.OpenBracketToken); 12243if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 12256this.EatToken(SyntaxKind.CloseBracketToken), 12263this.EatToken(SyntaxKind.StackAllocKeyword), 12265this.CurrentToken.Kind == SyntaxKind.OpenBraceToken ? this.ParseArrayInitializer() : null); 12278if (modifiers.Any((int)SyntaxKind.AsyncKeyword)) 12283var @delegate = this.EatToken(SyntaxKind.DelegateKeyword); 12286if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 12299if (this.CurrentToken.Kind != SyntaxKind.OpenBraceToken) 12302var openBrace = this.EatToken(SyntaxKind.OpenBraceToken); 12311SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)), 12330if (this.CurrentToken.Kind == SyntaxKind.StaticKeyword) 12332modifiers.Add(this.EatToken(SyntaxKind.StaticKeyword)); 12336if (this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword && 12339modifiers.Add(this.EatContextualToken(SyntaxKind.AsyncKeyword)); 12351Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.AsyncKeyword); 12355case SyntaxKind.OpenParenToken: 12356case SyntaxKind.IdentifierToken: 12357case SyntaxKind.StaticKeyword: 12358case SyntaxKind.RefKeyword: 12359case SyntaxKind.DelegateKeyword: 12376if (this.CurrentToken.Kind == SyntaxKind.ColonToken && 12397if (modifiers.Any((int)SyntaxKind.AsyncKeyword)) 12406if (CurrentToken.Kind != SyntaxKind.OpenParenToken) 12413if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 12416var arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken); 12427var identifier = (this.CurrentToken.Kind != SyntaxKind.IdentifierToken && this.PeekToken(1).Kind == SyntaxKind.EqualsGreaterThanToken) 12428? this.EatTokenAsKind(SyntaxKind.IdentifierToken) 12440Debug.Assert(greaterThan.Kind == SyntaxKind.GreaterThanToken); 12441arrow = MergeAdjacent(equalsToken, greaterThan, SyntaxKind.EqualsGreaterThanToken); 12446arrow = this.EatToken(SyntaxKind.EqualsGreaterThanToken); 12459=> CurrentToken.Kind == SyntaxKind.OpenBraceToken 12465var openParen = this.EatToken(SyntaxKind.OpenParenToken); 12471SyntaxKind.CloseParenToken, 12484this.EatToken(SyntaxKind.CloseParenToken)); 12487LanguageParser @this, ref SyntaxToken openParen, SeparatedSyntaxListBuilder<ParameterSyntax> list, SyntaxKind expectedKind, SyntaxKind closeKind) 12490static p => p.CurrentToken.Kind != SyntaxKind.CommaToken && !p.IsPossibleLambdaParameter(), 12500case SyntaxKind.ParamsKeyword: 12501case SyntaxKind.ReadOnlyKeyword: 12504case SyntaxKind.RefKeyword: 12505case SyntaxKind.OutKeyword: 12506case SyntaxKind.InKeyword: 12507case SyntaxKind.OpenParenToken: // tuple 12508case SyntaxKind.OpenBracketToken: // attribute 12511case SyntaxKind.IdentifierToken: 12514case SyntaxKind.DelegateKeyword: 12529if (IsParameterModifierExcludingScoped(this.CurrentToken) || this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword) 12543equalsToken ??= TryEatToken(SyntaxKind.EqualsToken); 12564if (this.CurrentToken.Kind == SyntaxKind.OpenParenToken) 12587if (peek1.Kind != SyntaxKind.CommaToken && 12588peek1.Kind != SyntaxKind.CloseParenToken && 12589peek1.Kind != SyntaxKind.EqualsGreaterThanToken && 12590peek1.Kind != SyntaxKind.OpenBraceToken && 12591peek1.Kind != SyntaxKind.ExclamationToken && 12592peek1.Kind != SyntaxKind.EqualsToken) 12613case SyntaxKind.OnKeyword: 12614case SyntaxKind.EqualsKeyword: 12615case SyntaxKind.AscendingKeyword: 12616case SyntaxKind.DescendingKeyword: 12617case SyntaxKind.ByKeyword: 12628case SyntaxKind.FromKeyword: 12629case SyntaxKind.JoinKeyword: 12630case SyntaxKind.IntoKeyword: 12631case SyntaxKind.WhereKeyword: 12632case SyntaxKind.OrderByKeyword: 12633case SyntaxKind.GroupKeyword: 12634case SyntaxKind.SelectKeyword: 12635case SyntaxKind.LetKeyword: 12644return this.CurrentToken.ContextualKind == SyntaxKind.FromKeyword && 12652var pk1 = this.PeekToken(1).Kind; 12658if (pk1 == SyntaxKind.IdentifierToken) 12660var pk2 = this.PeekToken(2).Kind; 12661if (pk2 == SyntaxKind.InKeyword) 12668if (pk2 is SyntaxKind.SemicolonToken or // from x; 12669SyntaxKind.CommaToken or // from x, y; 12670SyntaxKind.EqualsToken) // from x = null; 12680if (pk2 is SyntaxKind.OpenParenToken or SyntaxKind.OpenBraceToken) 12697return this.ScanType() != ScanTypeFlags.NotType && this.CurrentToken.Kind is SyntaxKind.IdentifierToken or SyntaxKind.InKeyword; 12706fc = this.AddError(fc, ErrorCode.WRN_PrecedenceInversion, SyntaxFacts.GetText(SyntaxKind.FromKeyword)); 12723case SyntaxKind.FromKeyword: 12727case SyntaxKind.JoinKeyword: 12730case SyntaxKind.LetKeyword: 12733case SyntaxKind.WhereKeyword: 12736case SyntaxKind.OrderByKeyword: 12747SyntaxKind.SelectKeyword => this.ParseSelectClause(), 12748SyntaxKind.GroupKeyword => this.ParseGroupClause(), 12750this.EatToken(SyntaxKind.SelectKeyword, ErrorCode.ERR_ExpectedSelectOrGroup), 12757this.CurrentToken.ContextualKind == SyntaxKind.IntoKeyword 12764Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.FromKeyword); 12765var @from = this.EatContextualToken(SyntaxKind.FromKeyword); 12767var type = this.PeekToken(1).Kind != SyntaxKind.InKeyword 12772if (this.PeekToken(1).ContextualKind == SyntaxKind.InKeyword && 12773(this.CurrentToken.Kind != SyntaxKind.IdentifierToken || SyntaxFacts.IsQueryContextualKeyword(this.CurrentToken.ContextualKind))) 12779name = WithAdditionalDiagnostics(name, this.GetExpectedTokenError(SyntaxKind.IdentifierToken, name.ContextualKind, name.GetLeadingTriviaWidth(), name.Width)); 12780name = this.ConvertToMissingWithTrailingTrivia(name, SyntaxKind.IdentifierToken); 12791this.EatToken(SyntaxKind.InKeyword), 12797Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.JoinKeyword); 12799joinKeyword: this.EatContextualToken(SyntaxKind.JoinKeyword), 12800type: this.PeekToken(1).Kind != SyntaxKind.InKeyword 12804inKeyword: this.EatToken(SyntaxKind.InKeyword), 12806onKeyword: this.EatContextualToken(SyntaxKind.OnKeyword, ErrorCode.ERR_ExpectedContextualKeywordOn), 12808equalsKeyword: this.EatContextualToken(SyntaxKind.EqualsKeyword, ErrorCode.ERR_ExpectedContextualKeywordEquals), 12810into: this.CurrentToken.ContextualKind == SyntaxKind.IntoKeyword 12817Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.LetKeyword); 12819this.EatContextualToken(SyntaxKind.LetKeyword), 12821this.EatToken(SyntaxKind.EqualsToken), 12827Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.WhereKeyword); 12829this.EatContextualToken(SyntaxKind.WhereKeyword), 12835Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.OrderByKeyword); 12836var @orderby = this.EatContextualToken(SyntaxKind.OrderByKeyword); 12843while (this.CurrentToken.Kind == SyntaxKind.CommaToken) 12845if (this.CurrentToken.Kind is SyntaxKind.CloseParenToken or SyntaxKind.SemicolonToken) 12849else if (this.CurrentToken.Kind == SyntaxKind.CommaToken) 12851list.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); 12855else if (skipBadOrderingListTokens(list, SyntaxKind.CommaToken) == PostSkipAction.Abort) 12865PostSkipAction skipBadOrderingListTokens(SeparatedSyntaxListBuilder<OrderingSyntax> list, SyntaxKind expected) 12870static p => p.CurrentToken.Kind != SyntaxKind.CommaToken, 12871static (p, _) => p.CurrentToken.Kind == SyntaxKind.CloseParenToken 12872|| p.CurrentToken.Kind == SyntaxKind.SemicolonToken 12882SyntaxKind kind = SyntaxKind.AscendingOrdering; 12884if (this.CurrentToken.ContextualKind is SyntaxKind.AscendingKeyword or SyntaxKind.DescendingKeyword) 12887if (direction.Kind == SyntaxKind.DescendingKeyword) 12889kind = SyntaxKind.DescendingOrdering; 12898Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.SelectKeyword); 12900this.EatContextualToken(SyntaxKind.SelectKeyword), 12906Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.GroupKeyword); 12908this.EatContextualToken(SyntaxKind.GroupKeyword), 12910this.EatContextualToken(SyntaxKind.ByKeyword, ErrorCode.ERR_ExpectedContextualKeywordBy), 12916Debug.Assert(this.CurrentToken.ContextualKind == SyntaxKind.IntoKeyword); 12918this.EatContextualToken(SyntaxKind.IntoKeyword), 12980LanguageParser parser, ref SyntaxToken openToken, SeparatedSyntaxListBuilder<TNode> builder, SyntaxKind expectedKind, SyntaxKind closeTokenKind) where TNode : GreenNode; 13011SyntaxKind closeTokenKind, 13021var separatorTokenKind = SyntaxKind.CommaToken; 13046nodes.AddSeparator(this.CurrentToken.Kind == SyntaxKind.SemicolonToken 13072else if (skipBadTokens(this, ref openToken, nodes, SyntaxKind.IdentifierToken, closeTokenKind) == PostSkipAction.Continue) 13092if (allowSemicolonAsSeparator && this.CurrentToken.Kind is SyntaxKind.SemicolonToken) 13174if (this.CurrentToken.Kind == SyntaxKind.EndOfFileToken) return node; 13176while (this.CurrentToken.Kind != SyntaxKind.EndOfFileToken)