BoundLiteral

Binder\Binder_Attributes.cs (1)

391(arguments[argIndex].IsParamsArrayOrCollection && arguments[argIndex] is BoundArrayCreation { Bounds: [BoundLiteral { ConstantValueOpt.Value: 0 }] }) ?

Binder\Binder_Await.cs (1)

640var receiver = new BoundLiteral(node, ConstantValue.Null, awaiterType);

Binder\Binder_Expressions.cs (2)

7539private BoundLiteral BindLiteralConstant(LiteralExpressionSyntax node, BindingDiagnosticBag diagnostics) 8023if (boundLeft.Kind == BoundKind.Literal && ((BoundLiteral)boundLeft).ConstantValueOpt == ConstantValue.Null)

Binder\Binder_InterpolatedString.cs (7)

98BoundLiteral? format = null; 407Debug.Assert(part is BoundLiteral && part.ConstantValueOpt?.StringValue != null); 436=> parts.All(p => p is BoundLiteral or BoundStringInsert { Value.Type.SpecialType: SpecialType.System_String, Alignment: null, Format: null }); 887Debug.Assert(part is BoundLiteral { Type: { SpecialType: SpecialType.System_String }, ConstantValueOpt.IsString: true }); 920Debug.Assert(part is BoundLiteral or BoundStringInsert); 951var boundLiteral = (BoundLiteral)part;

Binder\Binder_Operators.cs (2)

4336BoundLiteral constant = BindIntegralMinValConstants(node, operand, diagnostics); 4673private BoundLiteral BindIntegralMinValConstants(PrefixUnaryExpressionSyntax node, BoundExpression operand, BindingDiagnosticBag diagnostics)

Binder\Binder_TupleOperators.cs (1)

101case BoundLiteral _:

Binder\ForEachLoopBinder.cs (1)

951if (collectionExpr is BoundLiteral && collectionExpr.ConstantValueOpt is { IsNull: true })

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

1772BoundLiteral intMaxValueLiteral = new BoundLiteral(syntaxNode, ConstantValue.Create(int.MaxValue), expectedAttributeType);

Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (1)

1410=> argument is BoundLiteral { Type.SpecialType: SpecialType.System_String } &&

BoundTree\BoundNode.cs (1)

362this is BoundArrayCreation { Bounds: [BoundLiteral { WasCompilerGenerated: true }], InitializerOpt: BoundArrayInitialization { WasCompilerGenerated: true }, WasCompilerGenerated: true } or

BoundTree\BoundTreeVisitors.cs (1)

98return VisitLiteral(node as BoundLiteral, arg);

Compilation\CSharpCompilation.cs (1)

2292var dumbInstance = new BoundLiteral(syntax, ConstantValue.Null, namedType);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

205BoundLiteral boundHashFactor = null;

Compiler\MethodBodySynthesizer.Lowered.cs (1)

356ref BoundLiteral? boundHashFactor,

FlowAnalysis\AbstractFlowPass.cs (1)

1671public override BoundNode VisitLiteral(BoundLiteral node)

FlowAnalysis\NullableWalker.cs (1)

13361public override BoundNode? VisitLiteral(BoundLiteral node)

Generated\BoundNodes.xml.Generated.cs (17)

4359public BoundLiteral Update(ConstantValue? constantValueOpt, TypeSymbol? type) 4363var result = new BoundLiteral(this.Syntax, constantValueOpt, type, this.HasErrors); 8036public BoundStringInsert(SyntaxNode syntax, BoundExpression value, BoundExpression? alignment, BoundLiteral? format, bool isInterpolatedStringHandlerAppendCall, bool hasErrors = false) 8051public BoundLiteral? Format { get; } 8057public BoundStringInsert Update(BoundExpression value, BoundExpression? alignment, BoundLiteral? format, bool isInterpolatedStringHandlerAppendCall) 9304return VisitLiteral((BoundLiteral)node, arg); 9673public virtual R VisitLiteral(BoundLiteral node, A arg) => this.DefaultVisit(node, arg); 9914public virtual BoundNode? VisitLiteral(BoundLiteral node) => this.DefaultVisit(node); 10508public override BoundNode? VisitLiteral(BoundLiteral node) => null; 11832public override BoundNode? VisitLiteral(BoundLiteral node) 12500BoundLiteral? format = (BoundLiteral?)this.Visit(node.Format); 13969public override BoundNode? VisitLiteral(BoundLiteral node) 13976BoundLiteral updatedNode = node.Update(node.ConstantValueOpt, infoAndType.Type); 15173BoundLiteral? format = (BoundLiteral?)this.Visit(node.Format); 16472public override TreeDumperNode VisitLiteral(BoundLiteral node, object? arg) => new TreeDumperNode("literal", null, new TreeDumperNode[]

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

557var literal = operand as BoundLiteral;

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

449Debug.Assert(index is BoundParameterId or BoundLocalId or BoundLiteral);

Lowering\IteratorRewriter\IteratorMethodToStateMachineRewriter.cs (1)

297BoundLiteral result = this.F.Literal(!finished);

Lowering\LocalRewriter\LocalRewriter_Call.cs (3)

1097(array is BoundLocal && indices.All(e => e is BoundLocal or BoundLiteral))); 1327if (possibleParamsArray.IsParamsArrayOrCollection && !_inExpressionLambda && ((BoundArrayCreation)possibleParamsArray).Bounds is [BoundLiteral { ConstantValueOpt.Value: 0 }]) 1495if (paramsArray is BoundArrayCreation { Bounds: [BoundLiteral] bounds, InitializerOpt: BoundArrayInitialization { Initializers: var elements } initialization } creation)

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

1542var otherElements = _factory.Literal(initialLength);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

964Debug.Assert(loweredIndices[i] is BoundLiteral);

Lowering\LocalRewriter\LocalRewriter_Literal.cs (2)

17public override BoundNode VisitLiteral(BoundLiteral node) 23private BoundExpression MakeLiteral(SyntaxNode syntax, ConstantValue constantValue, TypeSymbol? type, BoundLiteral? oldNodeOpt = null)

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (1)

305else if (argument is BoundNullCoalescingOperator { LeftOperand: { Type.SpecialType: SpecialType.System_String } left, RightOperand: BoundLiteral { ConstantValueOpt: { IsString: true, RopeValue.IsEmpty: true } } })

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (1)

177Debug.Assert(part is BoundLiteral && part.ConstantValueOpt?.StringValue is not null);

Lowering\SyntheticBoundNodeFactory.cs (12)

Operations\CSharpOperationFactory.cs (8)

57return CreateBoundLiteralOperation((BoundLiteral)boundNode); 681internal ILiteralOperation CreateBoundLiteralOperation(BoundLiteral boundLiteral, bool @implicit = false) 1032Debug.Assert(!forceOperandImplicitLiteral || boundConversion.Operand is BoundLiteral); 1191? CreateBoundLiteralOperation((BoundLiteral)correctedConversionNode.Operand, @implicit: true) 2371builder.Add(CreateBoundInterpolatedStringTextOperation((BoundLiteral)part)); 2439BoundLiteral l => CreateBoundLiteralOperation(l, @implicit: true), 2440BoundConversion { Operand: BoundLiteral } c => CreateBoundConversionOperation(c, forceOperandImplicitLiteral: true), 2494private IInterpolatedStringTextOperation CreateBoundInterpolatedStringTextOperation(BoundLiteral boundNode)

Symbols\ReducedExtensionMethodSymbol.cs (3)

145var thisArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, thisType) { WasCompilerGenerated = true }; 147var otherArgumentValue = new BoundLiteral(syntax, ConstantValue.Bad, otherArgumentType) { WasCompilerGenerated = true }; 154var argument = (i == 0) ? thisArgumentValue : otherArgumentValue;

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1227var receiverValue = new BoundLiteral(syntax, ConstantValue.Bad, receiverType) { WasCompilerGenerated = true };

Symbols\Synthesized\Records\SynthesizedRecordGetHashCode.cs (1)

99BoundLiteral? boundHashFactor = null;