LiteralExpressionSyntax

Binder\Semantics\Conversions\ConversionsBase.cs (1)

1754var syntaxNode = new LiteralExpressionSyntax(greenNode, null, 0);

Syntax.xml.Internal.Generated.cs (1)

3175internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.LiteralExpressionSyntax(this, parent, position);

AppHostAnalyzer.cs (1)

132routePatternArgumentSyntax.Expression is not LiteralExpressionSyntax routePatternArgumentLiteralSyntax)

SyntaxNodeExtensionsTests.cs (1)

125Assert.False(((LiteralExpressionSyntax)null!).IdentifierNameEquals("a"));

Infrastructure\VirtualChars\CSharpVirtualCharService.cs (2)

81return token.GetRequiredParent() is LiteralExpressionSyntax literalExpression 190parentExpression is LiteralExpressionSyntax ||

Mvc\MvcAnalyzer.cs (1)

181if (attributeArgument.Expression is LiteralExpressionSyntax literalExpression)

RouteEmbeddedLanguage\FrameworkParametersCompletionProvider.cs (1)

309attributeArgument.Expression is LiteralExpressionSyntax literalExpression)

RouteEmbeddedLanguage\Infrastructure\RouteStringSyntaxDetector.cs (1)

65if (token.Parent is not LiteralExpressionSyntax)

RouteEmbeddedLanguage\Infrastructure\RouteUsageDetector.cs (3)

52LiteralExpressionSyntax RouteStringExpression, 71if (token.Parent is not LiteralExpressionSyntax) 300if (routeStringArgument?.Expression is not LiteralExpressionSyntax literalExpression)

RouteEmbeddedLanguage\Infrastructure\SyntaxNodeExtensions.cs (1)

38=> node is LiteralExpressionSyntax;

RouteHandlers\RouteHandlerAnalyzer.cs (1)

185routePatternArgumentSyntax.Expression is not LiteralExpressionSyntax routePatternArgumentLiteralSyntax)

PersistentStateAnalyzer.cs (4)

90LiteralExpressionSyntax { Token.ValueText: "null" } => true, 92PostfixUnaryExpressionSyntax { Operand: LiteralExpressionSyntax { Token.ValueText: "null" }, OperatorToken.ValueText: "!" } => true, 94LiteralExpressionSyntax literal when literal.Token.IsKind(SyntaxKind.DefaultKeyword) => true, 96PostfixUnaryExpressionSyntax { Operand: LiteralExpressionSyntax literal, OperatorToken.ValueText: "!" }

SupplyParameterFromFormAnalyzer.cs (4)

90LiteralExpressionSyntax { Token.ValueText: "null" } => true, 92PostfixUnaryExpressionSyntax { Operand: LiteralExpressionSyntax { Token.ValueText: "null" }, OperatorToken.ValueText: "!" } => true, 94LiteralExpressionSyntax literal when literal.Token.IsKind(SyntaxKind.DefaultKeyword) => true, 96PostfixUnaryExpressionSyntax { Operand: LiteralExpressionSyntax literal, OperatorToken.ValueText: "!" }

XmlCommentGenerator.Parser.cs (1)

172if (argument.Expression is LiteralExpressionSyntax)

Binder\Binder_Expressions.cs (4)

716return BindLiteralConstant((LiteralExpressionSyntax)node, diagnostics); 719return BindUtf8StringLiteral((LiteralExpressionSyntax)node, diagnostics); 7373private BoundLiteral BindLiteralConstant(LiteralExpressionSyntax node, BindingDiagnosticBag diagnostics) 7429private BoundUtf8String BindUtf8StringLiteral(LiteralExpressionSyntax node, BindingDiagnosticBag diagnostics)

Binder\Binder_Operators.cs (2)

4548var literal = (LiteralExpressionSyntax)operand.Syntax;

Binder\Semantics\Conversions\ConversionsBase.cs (1)

1754var syntaxNode = new LiteralExpressionSyntax(greenNode, null, 0);

Symbols\Source\SourcePropertySymbolBase.cs (1)

506if (node.ArgumentList?.Arguments is not [{ NameColon: null, NameEquals: null, Expression: LiteralExpressionSyntax { RawKind: (int)SyntaxKind.StringLiteralExpression } }])

Syntax.xml.Main.Generated.cs (5)

127public virtual TResult? VisitLiteralExpression(LiteralExpressionSyntax node) => this.DefaultVisit(node); 871public virtual void VisitLiteralExpression(LiteralExpressionSyntax node) => this.DefaultVisit(node); 1614public override SyntaxNode? VisitLiteralExpression(LiteralExpressionSyntax node) 2940public static LiteralExpressionSyntax LiteralExpression(SyntaxKind kind, SyntaxToken token) 2972return (LiteralExpressionSyntax)Syntax.InternalSyntax.SyntaxFactory.LiteralExpression(kind, (Syntax.InternalSyntax.SyntaxToken)token.Node!).CreateRed();

Syntax.xml.Syntax.Generated.cs (3)

2020public LiteralExpressionSyntax Update(SyntaxToken token) 2024var newNode = SyntaxFactory.LiteralExpression(this.Kind(), token); 2032public LiteralExpressionSyntax WithToken(SyntaxToken token) => Update(token);

Syntax\CSharpPragmaWarningStateMap.cs (1)

127var token = ((LiteralExpressionSyntax)currentErrorCode).Token;

Syntax\LiteralExpressionSyntax.cs (1)

13public static LiteralExpressionSyntax LiteralExpression(SyntaxKind kind)

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

167if (localDeclarator.Initializer.Value is not LiteralExpressionSyntax and

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (1)

290LiteralExpressionSyntax);

src\Analyzers\CSharp\Analyzers\UseCoalesceExpression\CSharpUseCoalesceExpressionForIfNullStatementCheckDiagnosticAnalyzer.cs (2)

43if (condition is BinaryExpressionSyntax(SyntaxKind.EqualsExpression) { Right: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } binary) 48else if (condition is IsPatternExpressionSyntax { Pattern: ConstantPatternSyntax { Expression: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } } isPattern)

src\Analyzers\CSharp\Analyzers\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.cs (2)

179if (condition is BinaryExpressionSyntax(SyntaxKind.EqualsExpression) { Right: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } binaryExpression) 188else if (condition is IsPatternExpressionSyntax { Pattern: ConstantPatternSyntax { Expression: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } } isPattern)

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (1)

78if (argument.Expression is not LiteralExpressionSyntax(SyntaxKind.StringLiteralExpression) and not InterpolatedStringExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

72if (initializerExpression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (2)

82return token.GetRequiredParent() is LiteralExpressionSyntax literalExpression 179parentExpression is LiteralExpressionSyntax ||

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\DefaultExpressionSyntaxExtensions.cs (1)

15private static readonly LiteralExpressionSyntax s_defaultLiteralExpression =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

485if (expression is LiteralExpressionSyntax && !expression.IsParentKind(SyntaxKind.UnaryMinusExpression)) 598if (!(expression is LiteralExpressionSyntax && expression.IsParentKind(SyntaxKind.UnaryMinusExpression)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ParenthesizedExpressionSyntaxExtensions.cs (1)

246if (expression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

1458=> node is LiteralExpressionSyntax; 1687=> ((LiteralExpressionSyntax)node).Token;

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateConversionCodeFixProvider.cs (1)

41node is LiteralExpressionSyntax ||

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateMethodCodeFixProvider.cs (1)

60node is LiteralExpressionSyntax ||

src\Analyzers\CSharp\CodeFixes\PopulateSwitch\CSharpPopulateSwitchExpressionCodeFixProvider.cs (1)

37=> SwitchExpressionArm(ConstantPattern((LiteralExpressionSyntax)generator.NullLiteralExpression()), Exception(generator, compilation));

src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (4)

45token.Parent is LiteralExpressionSyntax(SyntaxKind.DefaultLiteralExpression) defaultLiteral) 70var defaultLiteral = (LiteralExpressionSyntax)defaultToken.GetRequiredParent(); 79LiteralExpressionSyntax defaultLiteral,

src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs (1)

24private static readonly LiteralExpressionSyntax s_nullLiteralExpression

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (3)

124var numericLiteral = (LiteralExpressionSyntax)binaryExpression.Left; 138else if (lastExpression is LiteralExpressionSyntax(SyntaxKind.NumericLiteralExpression) numericLiteral)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (2)

98if (intermediaryValue is not LiteralExpressionSyntax and not PrefixUnaryExpressionSyntax) 278var literal = LiteralExpression(

CompleteStatement\CompleteStatementCommandHandler.cs (1)

486if (currentNode.IsKind(SyntaxKind.StringLiteralExpression, out LiteralExpressionSyntax? literalExpression)

StringCopyPaste\AbstractPasteProcessor.cs (1)

54/// The <see cref="LiteralExpressionSyntax"/> or <see cref="InterpolatedStringExpressionSyntax"/> that the

StringCopyPaste\KnownSourcePasteProcessor.cs (2)

74var isLiteral = StringExpressionBeforePaste is LiteralExpressionSyntax; 249var isLiteral = StringExpressionBeforePaste is LiteralExpressionSyntax;

StringCopyPaste\StringCopyPasteCommandHandler.cs (1)

307/// Returns the <see cref="LiteralExpressionSyntax"/> or <see cref="InterpolatedStringExpressionSyntax"/> if the

StringCopyPaste\StringCopyPasteData.cs (2)

70LiteralExpressionSyntax literal => TryCreateForLiteral(virtualCharService, literal, selectionSpan), 75private static StringCopyPasteData? TryCreateForLiteral(IVirtualCharLanguageService virtualCharService, LiteralExpressionSyntax literal, TextSpan span)

StringCopyPaste\StringCopyPasteHelpers.cs (7)

39if (stringExpression is LiteralExpressionSyntax) 152=> stringExpression is LiteralExpressionSyntax literalExpression && literalExpression.Token.IsVerbatimStringLiteral() || 156=> expression is LiteralExpressionSyntax literal 161=> expression is LiteralExpressionSyntax { Token.RawKind: (int)SyntaxKind.MultiLineRawStringLiteralToken } or 167public static bool IsRawStringLiteral(LiteralExpressionSyntax literal) 248if (current is LiteralExpressionSyntax literalExpression) 264if (expression is LiteralExpressionSyntax

StringCopyPaste\StringInfo.cs (4)

65LiteralExpressionSyntax literal => GetStringLiteralInfo(text, literal), 70private static StringInfo GetStringLiteralInfo(SourceText text, LiteralExpressionSyntax literal) 84private static StringInfo GetRawStringLiteralInfo(SourceText text, LiteralExpressionSyntax literal) 156private static StringInfo GetNormalStringLiteralStringInfo(SourceText text, LiteralExpressionSyntax literal)

Structure\StringLiteralExpressionStructureTests.cs (1)

15public sealed class StringLiteralExpressionStructureTests : AbstractCSharpSyntaxNodeStructureTests<LiteralExpressionSyntax>

CodeGen\CodeGenFunctionPointersTests.cs (1)

4920.OfType<LiteralExpressionSyntax>()

CodeGen\CodeGenTupleEqualityTests.cs (23)

CodeGen\CodeGenTupleTest.cs (16)

FlowAnalysis\RegionAnalysisTests.cs (4)

8099var expr = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 8127var expr = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

Semantics\ExtensionTests.cs (7)

18424var defaultExpr = GetSyntax<LiteralExpressionSyntax>(tree, "default"); 35483var literal = GetSyntax<LiteralExpressionSyntax>(tree, "42"); 35541var literal = GetSyntax<LiteralExpressionSyntax>(tree, "42"); 38145int position = GetSyntax<LiteralExpressionSyntax>(tree, "null").EndPosition - 1;

Semantics\OutVarTests.cs (2)

32495var one = node0.DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

Semantics\ParamsCollectionTests.cs (21)

Semantics\PatternMatchingTests.cs (2)

11365var exprs = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 11367foreach (var expr in exprs)

Semantics\PrimaryConstructorTests.cs (4)

3779var literal = (LiteralExpressionSyntax)context.Node; 5281var literal = (LiteralExpressionSyntax)context.Node;

Semantics\RecordTests.cs (2)

26313var literal = (LiteralExpressionSyntax)context.Node;

EndToEndTests.cs (2)

614var literals = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 616foreach (var literal in literals)

CodeFixes\Suppression\CSharpSuppressionCodeFixProvider.cs (5)

180var category = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(diagnostic.Descriptor.Category)); 185var ruleId = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(ruleIdText)); 188var justificationExpr = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(FeaturesResources.Pending)); 198var scopeExpr = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(scopeString)); 202var targetExpr = LiteralExpression(SyntaxKind.StringLiteralExpression, Literal(targetString));

ConvertBetweenRegularAndVerbatimString\ConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs (8)

19: AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider<LiteralExpressionSyntax> 29protected override bool IsAppropriateLiteralKind(LiteralExpressionSyntax literalExpression) 32protected override void AddSubStringTokens(LiteralExpressionSyntax literalExpression, ArrayBuilder<SyntaxToken> subStringTokens) 35protected override bool IsVerbatim(LiteralExpressionSyntax literalExpression) 38protected override LiteralExpressionSyntax CreateVerbatimStringExpression(IVirtualCharService charService, StringBuilder sb, LiteralExpressionSyntax stringExpression) 48protected override LiteralExpressionSyntax CreateRegularStringExpression(IVirtualCharService charService, StringBuilder sb, LiteralExpressionSyntax stringExpression)

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.Rewriting.cs (1)

96if (label.Pattern is AnalyzedPattern.Source { PatternSyntax: ConstantPatternSyntax { Expression: LiteralExpressionSyntax literal } })

ConvertLinq\ConvertForEachToLinqQuery\ToCountConverter.cs (1)

29=> expression is LiteralExpressionSyntax literalExpression && literalExpression.Token.ValueText == "0";

ConvertNumericLiteral\CSharpConvertNumericLiteralCodeRefactoringProvider.cs (1)

17: AbstractConvertNumericLiteralCodeRefactoringProvider<LiteralExpressionSyntax>(hexPrefix: "0x", binaryPrefix: "0b")

ConvertToInterpolatedString\CSharpConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)

19LiteralExpressionSyntax,

ConvertToRawString\ConvertInterpolatedStringToRawStringCodeRefactoringProvider.cs (1)

500if (descendant is LiteralExpressionSyntax(kind: SyntaxKind.StringLiteralExpression) ||

ConvertToRawString\ConvertRegularStringToRawStringCodeRefactoringProvider.cs (5)

22: AbstractConvertStringProvider<LiteralExpressionSyntax> 30protected override bool CheckSyntax(LiteralExpressionSyntax stringExpression) 35LiteralExpressionSyntax stringExpression, 124protected override LiteralExpressionSyntax Convert( 126LiteralExpressionSyntax stringExpression,

ConvertTupleToStruct\CSharpConvertTupleToStructCodeRefactoringProvider.cs (1)

21LiteralExpressionSyntax,

Debugging\DataTipInfoGetter.cs (1)

44else if (expression is LiteralExpressionSyntax)

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (1)

513var methodReturnDefaultValue = this.AnalyzerResult.CoreReturnType.IsReferenceType

InlineHints\CSharpInlineParameterNameHintsService.cs (1)

89LiteralExpressionSyntax or InterpolatedStringExpressionSyntax => HintKind.Literal,

QuickInfo\CSharpDiagnosticAnalyzerQuickInfoProvider.cs (1)

76LiteralExpressionSyntax(SyntaxKind.NumericLiteralExpression) literal

ReverseForStatement\CSharpReverseForStatementCodeRefactoringProvider.cs (1)

196=> expression.WalkDownParentheses() is LiteralExpressionSyntax literal && literal.Token.Value is 1;

SplitStringLiteral\SimpleStringSplitter.cs (2)

64var leftExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, firstToken); 65var rightExpression = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, secondToken);

src\Analyzers\CSharp\Analyzers\InlineDeclaration\CSharpInlineDeclarationDiagnosticAnalyzer.cs (1)

167if (localDeclarator.Initializer.Value is not LiteralExpressionSyntax and

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (1)

290LiteralExpressionSyntax);

src\Analyzers\CSharp\Analyzers\UseCoalesceExpression\CSharpUseCoalesceExpressionForIfNullStatementCheckDiagnosticAnalyzer.cs (2)

43if (condition is BinaryExpressionSyntax(SyntaxKind.EqualsExpression) { Right: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } binary) 48else if (condition is IsPatternExpressionSyntax { Pattern: ConstantPatternSyntax { Expression: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } } isPattern)

src\Analyzers\CSharp\Analyzers\UseCompoundAssignment\CSharpUseCompoundCoalesceAssignmentDiagnosticAnalyzer.cs (2)

179if (condition is BinaryExpressionSyntax(SyntaxKind.EqualsExpression) { Right: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } binaryExpression) 188else if (condition is IsPatternExpressionSyntax { Pattern: ConstantPatternSyntax { Expression: LiteralExpressionSyntax(SyntaxKind.NullLiteralExpression) } } isPattern)

src\Analyzers\CSharp\Analyzers\UseNameofInNullableAttribute\CSharpUseNameofInNullableAttributeDiagnosticAnalyzer.cs (1)

78if (argument.Expression is not LiteralExpressionSyntax(SyntaxKind.StringLiteralExpression) and not InterpolatedStringExpressionSyntax)

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateConversionCodeFixProvider.cs (1)

41node is LiteralExpressionSyntax ||

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateMethodCodeFixProvider.cs (1)

60node is LiteralExpressionSyntax ||

src\Analyzers\CSharp\CodeFixes\PopulateSwitch\CSharpPopulateSwitchExpressionCodeFixProvider.cs (1)

37=> SwitchExpressionArm(ConstantPattern((LiteralExpressionSyntax)generator.NullLiteralExpression()), Exception(generator, compilation));

src\Analyzers\CSharp\CodeFixes\ReplaceDefaultLiteral\CSharpReplaceDefaultLiteralCodeFixProvider.cs (4)

45token.Parent is LiteralExpressionSyntax(SyntaxKind.DefaultLiteralExpression) defaultLiteral) 70var defaultLiteral = (LiteralExpressionSyntax)defaultToken.GetRequiredParent(); 79LiteralExpressionSyntax defaultLiteral,

src\Analyzers\CSharp\CodeFixes\UseIsNullCheck\CSharpUseIsNullCheckForReferenceEqualsCodeFixProvider.cs (1)

24private static readonly LiteralExpressionSyntax s_nullLiteralExpression

Structure\CSharpBlockStructureProvider.cs (1)

52builder.Add<LiteralExpressionSyntax, StringLiteralExpressionStructureProvider>();

Structure\Providers\StringLiteralExpressionStructureProvider.cs (2)

12internal sealed class StringLiteralExpressionStructureProvider : AbstractSyntaxNodeStructureProvider<LiteralExpressionSyntax> 16LiteralExpressionSyntax node,

EditAndContinue\SyntaxUtilitiesTests.cs (2)

82var leftPosition = leftRoot.DescendantNodes().OfType<LiteralExpressionSyntax>().ElementAt(2).SpanStart; // 0 within Console.WriteLine(0) 129var leftPosition = leftRoot.DescendantNodes().OfType<LiteralExpressionSyntax>().ElementAt(5).SpanStart; // 3 within Console.WriteLine(3)

IOperation\IOperationTests.cs (2)

588var literal = root.DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

IOperation\IOperationTests_IVariableDeclaration.cs (2)

927var literalExpr = nodes.OfType<LiteralExpressionSyntax>().ElementAt(0);

Semantics\ExpressionBodiedMemberTests.cs (2)

97var semanticInfo = GetSemanticInfoForTest<LiteralExpressionSyntax>(@" 1021var nodes = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray();

Semantics\ImplicitObjectCreationTests.cs (2)

4153var node = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

Semantics\NullableReferenceTypesTests.cs (12)

56119var nullNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First(); 56149var nullNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First(); 56182var defaultNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First(); 56219var defaultNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First(); 56347var nullNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First(); 56551var nullNode = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().First();

Semantics\NullCoalesceAssignmentTests.cs (2)

184var defaultLiteral = syntaxRoot.DescendantNodes().OfType<LiteralExpressionSyntax>().Where(expr => expr.IsKind(SyntaxKind.DefaultLiteralExpression)).Single();

Semantics\ObjectAndCollectionInitializerTests.cs (10)

3814var literals = syntax.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 3816foreach (var literal in literals) 3837var literals = syntax.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 3839foreach (var literal in literals) 3861var literals = syntax.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 3863foreach (var literal in literals) 4096var nodes = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(n => n.ToString() == "2"); 4097var node = nodes.First(); 4168var nodes = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(n => n.ToString() == "2"); 4169var node = nodes.First();

Semantics\RecordStructTests.cs (2)

6041var literal = (LiteralExpressionSyntax)context.Node;

Semantics\SyntaxTreeRootTests.cs (2)

75var node = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3)); 83var node = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(3));

Semantics\TargetTypedDefaultTests.cs (80)

Semantics\TopLevelStatementsTests.cs (1)

9817Assert.Equal(OperationKind.Literal, model.GetOperation(tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single()).Kind);

Compilation\GetSemanticInfoBrokenCodeTests.cs (2)

267var literalSyntax = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

Compilation\GetSemanticInfoTests.cs (12)

3607var literal = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 3632var literal = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 3665var literal = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 3701var literal = tree.GetCompilationUnitRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 4752var trueLiteral = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 5582var nullSyntax = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

Compilation\SemanticModelAPITests.cs (3)

925var exprs = root.DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 4242var actual = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray(); 4270var actual = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().ToArray();

Compilation\SemanticModelGetSemanticInfoTests.cs (23)

Symbols\StaticAbstractMembersInInterfacesTests.cs (10)

20098var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(l => l.ToString() == "default").First(); 20181var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(l => l.ToString() == "default").First(); 20273var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(l => l.ToString() == "default").First(); 20362var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(l => l.ToString() == "default").First(); 29311var node = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Where(l => l.ToString() == "default").First();

Symbols\TypeTests.cs (1)

1783tinfo = model.GetTypeInfo(nodes[2] as LiteralExpressionSyntax);

Generated\Syntax.Test.xml.Generated.cs (5)

10471private static LiteralExpressionSyntax GenerateLiteralExpression() 11517var node = GenerateLiteralExpression(); 11520var newNode = node.WithToken(node.Token); 15225var oldNode = GenerateLiteralExpression(); 15241var oldNode = GenerateLiteralExpression();

LexicalAndXml\PreprocessorTests.cs (1)

340var token = (actualWarningNumber as LiteralExpressionSyntax).Token;

LexicalAndXml\RawStringLiteralLexingTests.cs (1)

188var literal = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, token);

Parsing\ExpressionParsingTests.cs (10)

459var us = (LiteralExpressionSyntax)expr; 514var us = (LiteralExpressionSyntax)expr; 529var us = (LiteralExpressionSyntax)expr; 544var us = (LiteralExpressionSyntax)expr; 558var us = (LiteralExpressionSyntax)expr;

Syntax\SyntaxFactoryTests.cs (4)

448var expression = (LiteralExpressionSyntax)SyntaxFactory.ParseExpression("1l"); 462var expression = (LiteralExpressionSyntax)SyntaxFactory.ParseExpression("1L");

Syntax\SyntaxRewriterTests.cs (3)

363var before = root.DescendantNodes().OfType<LiteralExpressionSyntax>().Single(); 364var after = SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("After"));

Classification\Worker_Preprocesser.cs (1)

122if (node is LiteralExpressionSyntax literal)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

72if (initializerExpression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (2)

82return token.GetRequiredParent() is LiteralExpressionSyntax literalExpression 179parentExpression is LiteralExpressionSyntax ||

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\DefaultExpressionSyntaxExtensions.cs (1)

15private static readonly LiteralExpressionSyntax s_defaultLiteralExpression =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

485if (expression is LiteralExpressionSyntax && !expression.IsParentKind(SyntaxKind.UnaryMinusExpression)) 598if (!(expression is LiteralExpressionSyntax && expression.IsParentKind(SyntaxKind.UnaryMinusExpression)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ParenthesizedExpressionSyntaxExtensions.cs (1)

246if (expression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

1458=> node is LiteralExpressionSyntax; 1687=> ((LiteralExpressionSyntax)node).Token;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (3)

124var numericLiteral = (LiteralExpressionSyntax)binaryExpression.Left; 138else if (lastExpression is LiteralExpressionSyntax(SyntaxKind.NumericLiteralExpression) numericLiteral)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (2)

98if (intermediaryValue is not LiteralExpressionSyntax and not PrefixUnaryExpressionSyntax) 278var literal = LiteralExpression(

CodeGeneration\SyntaxGeneratorTests.cs (39)

EmbeddedLanguages\VirtualChars\CSharpVirtualCharServiceTests.cs (1)

28if (expression is LiteralExpressionSyntax literal)

Diagnostics\OperationTests.cs (2)

310var literal = tree.GetRoot().DescendantNodes().OfType<LiteralExpressionSyntax>().Single();

BatchFixAllProviderTests.cs (2)

61var node = (LiteralExpressionSyntax)context.Node;

Analyzers\ConvertToLibraryImportFixer.cs (1)

511string? entryPoint = (string?)((LiteralExpressionSyntax)attrArg.Expression).Token.Value;

Marshalling\ElementsMarshalling.cs (1)

90static LiteralExpressionSyntax GetConstSizeExpression(int size)

Utils\SyntaxFactoryExtensions.cs (1)

97public static LiteralExpressionSyntax IntLiteral(int number) => LiteralExpression(SyntaxKind.NumericLiteralExpression, Literal(number));

BindingSourceGenerator.cs (2)

58 && invocation.ArgumentList.Arguments[1].Expression is not LiteralExpressionSyntax 68 && invocation.ArgumentList.Arguments[0].Expression is not LiteralExpressionSyntax

ContractsCheckNameofFixProvider.cs (1)

45string nameArgValue = (nameArg.Expression as LiteralExpressionSyntax)?.Token.ValueText;

CodeModel\CSharpCodeModelService.CodeModelEventCollector.cs (1)

150if (oldExpression is LiteralExpressionSyntax)

CSharpSpecializedEnumerableCreationAnalyzer.cs (1)

86.FirstOrDefault(n => n.IsKind(SyntaxKind.NumericLiteralExpression)) is LiteralExpressionSyntax literalRankSpecifier)

NumberCommentsRefactoring.cs (4)

37var literal = await context.TryGetRelevantNodeAsync<LiteralExpressionSyntax>(CSharpRefactoringHelpers.Instance).ConfigureAwait(false); 51private static async Task<Document> FixCommentsAsync(Document document, LiteralExpressionSyntax stringLiteral, CancellationToken c) 59var newStringLiteral = stringLiteral.Update(newToken);

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

72if (initializerExpression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\EmbeddedLanguages\VirtualChars\CSharpVirtualCharService.cs (2)

82return token.GetRequiredParent() is LiteralExpressionSyntax literalExpression 179parentExpression is LiteralExpressionSyntax ||

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\DefaultExpressionSyntaxExtensions.cs (1)

15private static readonly LiteralExpressionSyntax s_defaultLiteralExpression =

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

485if (expression is LiteralExpressionSyntax && !expression.IsParentKind(SyntaxKind.UnaryMinusExpression)) 598if (!(expression is LiteralExpressionSyntax && expression.IsParentKind(SyntaxKind.UnaryMinusExpression)))

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ParenthesizedExpressionSyntaxExtensions.cs (1)

246if (expression is LiteralExpressionSyntax)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SyntaxFacts\CSharpSyntaxFacts.cs (2)

1458=> node is LiteralExpressionSyntax; 1687=> ((LiteralExpressionSyntax)node).Token;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\EnumMemberGenerator.cs (3)

124var numericLiteral = (LiteralExpressionSyntax)binaryExpression.Left; 138else if (lastExpression is LiteralExpressionSyntax(SyntaxKind.NumericLiteralExpression) numericLiteral)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ExpressionGenerator.cs (2)

98if (intermediaryValue is not LiteralExpressionSyntax and not PrefixUnaryExpressionSyntax) 278var literal = LiteralExpression(