BoundConversion

Binder\Binder.ValueChecks.cs (10)

1011var conversion = (BoundConversion)expr; 3886Debug.Assert(expr is BoundConversion conversion && 4219var conversion = (BoundConversion)expr; 4547var conversion = (BoundConversion)expr; 5277var conversion = (BoundConversion)expr; 5667private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundConversion conversion, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)

Binder\Binder_Attributes.cs (2)

867return VisitConversion((BoundConversion)node, diagnostics, ref attrHasErrors, curArgumentHasErrors); 900private TypedConstant VisitConversion(BoundConversion node, BindingDiagnosticBag diagnostics, ref bool attrHasErrors, bool curArgumentHasErrors)

Binder\Binder_Await.cs (1)

376if (argument is BoundConversion)

Binder\Binder_Conversions.cs (2)

67Debug.Assert(result is BoundConversion || (conversion.IsIdentity && ((object)result == source) || source.NeedsToBeConverted()) || hasErrors); 1683else if (arg is BoundConversion { Operand: BoundCollectionExpression { Elements: [BoundExpression collectionElement] } })

Binder\Binder_Deconstruct.cs (1)

161var boundConversion = new BoundConversion(

Binder\Binder_Expressions.cs (4)

5210case BoundConversion { Conversion.IsIdentity: true, Operand: BoundParameter param }: 6039if (argument is BoundConversion { Conversion.IsInterpolatedStringHandler: true, Operand: var operand }) 7641Debug.Assert(leftSymbol == (boundValue.ExpressionSymbol ?? ((BoundConversion)boundValue).Operand.ExpressionSymbol)); 9726else if (convertedIndex is BoundConversion { Operand: { ConstantValueOpt: { SpecialType: SpecialType.System_Int32, Int32Value: int constIndex } } operand })

Binder\Binder_Invocation.cs (1)

1974Debug.Assert(typeOrValue.ValueSymbol == (boundValue.ExpressionSymbol ?? ((BoundConversion)boundValue).Operand.ExpressionSymbol));

Binder\Binder_Operators.cs (8)

78var conversion = (BoundConversion)CreateConversion(node, placeholder, finalDynamicConversion, isCast: true, conversionGroupOpt: null, left.Type, diagnostics); 285if (finalConversion is not BoundConversion final) 2929BoundConversion leftConv = (BoundConversion)left; 2930BoundConversion rightConv = (BoundConversion)right; 3394if (resultConversion is not BoundConversion)

Binder\Binder_Patterns.cs (2)

700var conversion = (BoundConversion)convertedExpression;

Binder\Binder_Query.cs (2)

691var c1 = invocation.Arguments[index] as BoundConversion;

Binder\Binder_Statements.cs (2)

2692return BoundConversion.Synthesized(node, BindToTypeForErrorRecovery(expr), Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, boolean, hasErrors: true); 2759return BoundConversion.Synthesized(node, expr, Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, boolean, hasErrors: true);

Binder\ForEachLoopBinder.cs (1)

657if ((convertedCollectionExpression as BoundConversion)?.Operand != (object)collectionExpr)

Binder\RefSafetyAnalysis.cs (4)

747if (arg is BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler, Operand: BoundInterpolatedString or BoundBinaryOperator } conversion) 1114var right = node.Right; 1236case BoundConversion conv: 1261inlineArray: node.Expression is not BoundConversion { Conversion.IsIdentity: true, ExplicitCastInCode: false, Operand: BoundExpression operand } ? node.Expression : operand,

BoundTree\BoundExpression.cs (1)

486public BoundConversion UpdateOperand(BoundExpression operand)

BoundTree\BoundExpressionExtensions.cs (2)

255BoundConversion conversionNode = (BoundConversion)boundNode;

BoundTree\BoundNode.cs (6)

365BoundConversion { Operand: BoundCollectionExpression { IsParamsArrayOrCollection: true } }); 450case BoundConversion boundConversion: 459boundConversion = (BoundConversion)boundConversion.Operand; 464BoundConversion next; 467(object)(next = (BoundConversion)boundConversion.Operand).Operand == placeholder || 468(object)((BoundConversion)next.Operand).Operand == placeholder)

BoundTree\BoundNode_Source.cs (1)

308case BoundConversion conversion:

BoundTree\BoundTreeVisitors.cs (1)

64return VisitConversion(node as BoundConversion, arg);

BoundTree\Constructors.cs (2)

335public static BoundConversion SynthesizedNonUserDefined(SyntaxNode syntax, BoundExpression operand, Conversion conversion, TypeSymbol type, ConstantValue? constantValueOpt = null) 355public static BoundConversion Synthesized(

CodeGen\EmitConversion.cs (7)

40private void EmitConversionExpression(BoundConversion conversion, bool used) 91private void EmitConversion(BoundConversion conversion) 182private void EmitIdentityConversion(BoundConversion conversion) 212private void EmitNumericConversion(BoundConversion conversion) 225private void EmitImplicitReferenceConversion(BoundConversion conversion) 257private void EmitExplicitReferenceConversion(BoundConversion conversion) 284private void EmitEnumConversion(BoundConversion conversion)

CodeGen\EmitExpression.cs (10)

127EmitConversionExpression((BoundConversion)expression, used); 1244var conversion = (BoundConversion)receiver; 1284if (receiver.Kind == BoundKind.Conversion && ((BoundConversion)receiver).ConversionKind == ConversionKind.Unboxing) 1547var conversion = (BoundConversion)receiver; 2193BoundConversion conv = (BoundConversion)current; 3957var conversion = (BoundConversion)expr;

CodeGen\EmitOperators.cs (1)

375if (comparand is BoundConversion { Type.SpecialType: SpecialType.System_Object, ConversionKind: ConversionKind.Boxing, Operand.Type: TypeParameterSymbol { AllowsRefLikeType: true } } &&

CodeGen\Optimizer.cs (2)

592public override BoundNode VisitConversion(BoundConversion node) 996((BoundConversion)right).ConversionKind.IsPointerConversion())

Compilation\CSharpSemanticModel.cs (16)

1936highestBoundNode is BoundConversion { ConversionKind: ConversionKind.MethodGroup } boundConversion) 2104else if ((highestBoundExpr as BoundConversion)?.Conversion.IsTupleLiteralConversion == true) 2106var tupleLiteralConversion = (BoundConversion)highestBoundExpr; 2132if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.SwitchExpression, Conversion: var convertedSwitchConversion }) 2150if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.ConditionalExpression }) 2169if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.CollectionExpression or ConversionKind.NoConversion, Conversion: var convertedCollectionConversion }) 2175else if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.ImplicitNullable, Conversion.UnderlyingConversions: [{ Kind: ConversionKind.CollectionExpression }] } boundConversion) 2196else if (((BoundConversion)highestBoundExpr).Operand.Kind != BoundKind.Conversion) 2211conversion = binder.Conversions.ClassifyConversionFromExpression(boundExpr, convertedType, isChecked: ((BoundConversion)highestBoundExpr).Checked, ref discardedUseSiteInfo); 2243else if (boundExpr is BoundConversion { ConversionKind: ConversionKind.MethodGroup, Conversion: var exprConversion, Type: { TypeKind: TypeKind.FunctionPointer }, SymbolOpt: var symbol }) 3527var conversion = (BoundConversion)boundNode; 4303var conversion = (BoundConversion)boundNodeForSyntacticParent; 4310else if (conversion.Operand is BoundConversion { ConversionKind: ConversionKind.MethodGroup } nestedMethodGroupConversion)

Compilation\MemberSemanticModel.cs (2)

1044var boundConversion = boundDeconstruction.Right; 1846node = ((BoundConversion)node).Operand;

Compiler\MethodBodySynthesizer.cs (4)

123BoundConversion.Synthesized(syntax, 151BoundConversion.Synthesized(syntax, 397delegateUpdate = BoundConversion.SynthesizedNonUserDefined(syntax, 462delegateUpdate = BoundConversion.SynthesizedNonUserDefined(syntax,

FlowAnalysis\AbstractFlowPass.cs (5)

1739public override BoundNode VisitConversion(BoundConversion node) 1766protected virtual void AfterVisitConversion(BoundConversion node) 2662|| (expr is BoundConversion { ConversionKind: ConversionKind.ExplicitNullable or ConversionKind.ImplicitNullable } conv 3008BoundConversion { Conversion: Conversion conversion, Operand: BoundConditionalAccess ca } when CanPropagateStateWhenNotNull(conversion) => ca, 3116Debug.Assert(innerCondAccess.Receiver is not (BoundConditionalAccess or BoundConversion));

FlowAnalysis\AbstractRegionDataFlowPass.cs (1)

74protected override void AfterVisitConversion(BoundConversion node)

FlowAnalysis\DefiniteAssignment.cs (3)

879BoundConversion boundConversion = (BoundConversion)value; 2765protected override void AfterVisitConversion(BoundConversion node)

FlowAnalysis\NullableWalker.cs (41)

272/// The delegate is invoked by <see cref="VisitConversion(BoundConversion, BoundExpression, Conversion, TypeWithAnnotations, TypeWithState, bool, bool, bool, AssignmentKind, ParameterSymbol, bool, bool, bool, bool, Optional<LocalState>,bool, Location, ArrayBuilder<VisitResult>)"/>. 2157var conv = (BoundConversion)node; 2614var conversion = (BoundConversion)expr; 4062if (node.Conversion is BoundConversion { Conversion: var conversion }) 4903var expression = GetConversionIfApplicable(expressions[i], expressionNoConversion); 5400expr as BoundConversion, 5513expr as BoundConversion, 5667operand = ((BoundConversion)operand).Operand; 5861var conversion = (BoundConversion)possiblyConversion; 5970if ((node.RightOperand as BoundConversion)?.ExplicitCastInCode != false && 6024if (node is BoundConversion boundConversion) 6126Debug.Assert(innerCondAccess.Receiver is not (BoundConditionalAccess or BoundConversion)); 7498TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion); 7556elements = ((BoundCollectionExpression)((BoundConversion)argument).Operand).UnconvertedCollectionExpression.Elements.CastArray<BoundExpression>(); 7894BoundConversion? conversionOpt, 8685var conversion = (BoundConversion)expr; 8897public override BoundNode? VisitConversion(BoundConversion node) 9158BoundConversion? conversionOpt, 9382private static BoundConversion? GetConversionIfApplicable(BoundExpression? conversionOpt, BoundExpression convertedNode) 9389return conversionOpt == convertedNode ? null : (BoundConversion?)conversionOpt; 9412BoundConversion? conversionOpt, 9593if (useLegacyWarnings && conversionOperand is BoundConversion operandConversion && !operandConversion.ConversionKind.IsUserDefinedConversion()) 9972BoundConversion? conversionOpt, 10124var conversionOpt = conversionExpression as BoundConversion; 10132conversionOpt = conversionOpt.Operand as BoundConversion; 10136private void TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState resultType, BoundConversion? conversionOpt, BoundExpression convertedNode) 10152conversionOpt = conversionOpt.Operand as BoundConversion; 10777var right = node.Right; 11057var conv = (BoundConversion)expr; 11173if (node.OperandConversion is BoundConversion { Conversion: var operandConversion } && operandConversion.IsUserDefined && operandConversion.Method?.ParameterCount == 1) 11355node.LeftConversion as BoundConversion ?? node.Left, 11862if (!reportedDiagnostic && !(collectionExpression is BoundConversion { Operand: { IsSuppressed: true } })) 11950if (node.Expression is not BoundConversion { Operand.IsSuppressed: true } && 11987isSuppressed: node.Expression is BoundConversion { Operand.IsSuppressed: true }, 12120node.Operand as BoundConversion,

FlowAnalysis\NullableWalker.DebugVerifier.cs (2)

277if (node.LeftConversion is BoundConversion leftConversion && 394public override BoundNode? VisitConversion(BoundConversion node)

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

1865public BoundDeconstructionAssignmentOperator(SyntaxNode syntax, BoundTupleExpression left, BoundConversion right, bool isUsed, TypeSymbol type, bool hasErrors = false) 1880public BoundConversion Right { get; } 1886public BoundDeconstructionAssignmentOperator Update(BoundTupleExpression left, BoundConversion right, bool isUsed, TypeSymbol type) 3002public BoundConversion Update(BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, TypeSymbol type) 3006var result = new BoundConversion(this.Syntax, operand, conversion, isBaseConversion, @checked, explicitCastInCode, constantValueOpt, conversionGroupOpt, type, this.HasErrors); 9046return VisitConversion((BoundConversion)node, arg); 9444public virtual R VisitConversion(BoundConversion node, A arg) => this.DefaultVisit(node, arg); 9680public virtual BoundNode? VisitConversion(BoundConversion node) => this.DefaultVisit(node); 10108public override BoundNode? VisitConversion(BoundConversion node) 11154BoundConversion right = (BoundConversion)this.Visit(node.Right); 11348public override BoundNode? VisitConversion(BoundConversion node) 13008BoundConversion right = (BoundConversion)this.Visit(node.Right); 13476public override BoundNode? VisitConversion(BoundConversion node) 13479BoundConversion updatedNode; 15827public override TreeDumperNode VisitConversion(BoundConversion node, object? arg) => new TreeDumperNode("conversion", null, new TreeDumperNode[]

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

169public override BoundNode? VisitConversion(BoundConversion node)

Lowering\ClosureConversion\ClosureConversion.cs (1)

1392public override BoundNode VisitConversion(BoundConversion conversion)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (6)

205return VisitConversion((BoundConversion)node); 536var conversion = (BoundConversion)operand; 670var conversion = e as BoundConversion; 687private BoundExpression VisitConversion(BoundConversion node)

Lowering\DiagnosticsPass_ExpressionTrees.cs (2)

400!(node is BoundConversion) && 842public override BoundNode VisitConversion(BoundConversion node)

Lowering\DiagnosticsPass_Warnings.cs (19)

143BoundConversion conversion = (BoundConversion)receiver; 166BoundConversion conversion = current as BoundConversion; 288if (!node.Operator.Kind.IsDynamic() && node.LeftConversion is BoundConversion { Conversion: { IsIdentity: false, Exists: true } conversion }) 347return node.Kind == BoundKind.Conversion && ((BoundConversion)node).ExplicitCastInCode; 354var conv = (BoundConversion)node; 431for (BoundConversion conversion = operand as BoundConversion; 433conversion = conversion.Operand as BoundConversion) 579BoundConversion conv = (BoundConversion)operand; 611BoundConversion conv = (BoundConversion)expr; 867var conv = (BoundConversion)node; 891var conversion = (BoundConversion)right;

Lowering\Extensions.cs (4)

58var conversion = (BoundConversion)expr; 105var conversion = (BoundConversion)expr;

Lowering\LocalRewriter\LocalRewriter.cs (1)

1122return expr is BoundConversion { Conversion: { IsInterpolatedStringHandler: true }, Type: { IsValueType: true } };

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (1)

204public override BoundNode VisitConversion(BoundConversion node)

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (2)

723var conversion = (BoundConversion)expression;

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

584BoundConversion conv = (BoundConversion)current; 853if (argument is BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler, Operand: BoundInterpolatedString or BoundBinaryOperator } conversion) 861Debug.Assert(!((BoundConversion)argument).ExplicitCastInCode); 927if (argument is BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler, Operand: BoundInterpolatedString or BoundBinaryOperator } conversion) 933Debug.Assert(!((BoundConversion)argument).ExplicitCastInCode); 1479=> expr is BoundConversion conv && conv.ConversionKind == ConversionKind.AnonymousFunction;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

726var spreadElementConversion = expressionStatement.Expression is BoundConversion { Conversion: var actualConversion } ? actualConversion : Conversion.Identity; 1041if (spreadElement.IteratorBody is not BoundExpressionStatement expressionStatement || expressionStatement.Expression is BoundConversion { ConversionKind: not ConversionKind.Identity }) 1448var convertedExpression = (BoundConversion?)node.Conversion;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (2)

1026var conv = (BoundConversion)expression;

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (12)

18public override BoundNode VisitConversion(BoundConversion node) 249var conversion = (BoundConversion)rewrittenNode; 261BoundConversion? oldNodeOpt, 296BoundConversion? oldNodeOpt, 1009case BoundConversion { Conversion: { Kind: ConversionKind.ImplicitNullable }, Operand: var convertedArgument } 1014case BoundConversion { Conversion: { Kind: ConversionKind.ImplicitNullable, UnderlyingConversions: var underlying }, Operand: var convertedArgument } conversion 1121rewrittenOperand = BoundConversion.SynthesizedNonUserDefined(syntax, rewrittenOperand, Conversion.ImplicitEnumeration, rewrittenOperandType); 1134var result = new BoundConversion(syntax, rewrittenOperand, new Conversion(conversionKind, method, false), @checked, explicitCastInCode: explicitCastInCode, conversionGroup, constantValueOpt: null, rewrittenType); 1362return BoundConversion.Synthesized(syntax, rewrittenOperand, conversion, @checked: @checked, explicitCastInCode: true, conversionGroupOpt: null, constantValueOpt: null, rewrittenType); 1404return BoundConversion.Synthesized(syntax, rewrittenOperand, conv, @checked: @checked, explicitCastInCode: true, conversionGroupOpt: null, constantValueOpt: null, rewrittenType); 1525return BoundConversion.Synthesized(syntax, rewrittenOperand, conversion, @checked, explicitCastInCode: explicitCastInCode, conversionGroupOpt: null, constantValueOpt, rewrittenType);

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (5)

19var right = node.Right; 114Debug.Assert(right is not ({ Kind: BoundKind.TupleLiteral } or BoundConversion { Operand.Kind: BoundKind.TupleLiteral })); 117right is { Kind: BoundKind.ConvertedTupleLiteral } or BoundConversion { Operand.Kind: BoundKind.ConvertedTupleLiteral } 306var tupleConversion = (BoundConversion)right;

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (4)

129(BoundConversion)node.Expression, 142BoundConversion convertedCollection, 1218var boundConversion = (BoundConversion)node.Expression;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

762else if (unloweredExpr is BoundConversion { Operand: { Type: { SpecialType: SpecialType.System_Int32 } } operand })

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (4)

44if (leftConversion is BoundConversion { Conversion: { IsIdentity: false } }) 50if (leftConversion is not BoundConversion { Conversion: { Exists: true } }) 223var boundConversion = (BoundConversion)expression;

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

289if (argument is BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand: { Type.SpecialType: SpecialType.System_Char } operand }) 629BoundConversion conv = (BoundConversion)expr;

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (3)

16private BoundExpression RewriteInterpolatedStringConversion(BoundConversion conversion) 240if (arg is BoundConversion { Conversion: { Kind: ConversionKind.InterpolatedStringHandler }, ExplicitCastInCode: false, Operand: var operand }) 251Debug.Assert(arguments.All(arg => arg is not BoundConversion { Conversion: { IsInterpolatedStringHandler: true }, ExplicitCastInCode: false }));

Lowering\LocalRewriter\LocalRewriter_TupleBinaryOperator.cs (18)

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)

767while (expression is BoundConversion conversion)

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

508Debug.Assert(methodArgumentInfo.Arguments.All(arg => arg is not BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler }));

Lowering\SpillSequenceSpiller.cs (1)

1187public override BoundNode VisitConversion(BoundConversion node)

Lowering\SyntheticBoundNodeFactory.cs (2)

575expression = BoundConversion.Synthesized(Syntax, expression, conversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, CurrentFunction.ReturnType); 1252? BoundConversion.SynthesizedNonUserDefined(syntax, nullLiteral, Conversion.NullToPointer, type)

Operations\CSharpOperationFactory.cs (8)

90return CreateBoundConversionOperation((BoundConversion)boundNode); 1015private IOperation CreateBoundConversionOperation(BoundConversion boundConversion, bool forceOperandImplicitLiteral = false) 1077BoundConversion correctedConversionNode = boundConversion; 1098var nestedConversion = (BoundConversion)boundOperand; 1969boundForEachStatement.Expression is not BoundConversion { Conversion.IsIdentity: true, ExplicitCastInCode: false, Operand: BoundExpression operand } ? 2346BoundConversion { Operand: BoundLiteral } c => CreateBoundConversionOperation(c, forceOperandImplicitLiteral: true), 2408private IInterpolatedStringHandlerCreationOperation CreateInterpolatedStringHandler(BoundConversion conversion)

Operations\CSharpOperationFactory_Methods.cs (2)

39IOperation value = Create(expression is BoundConversion { IsParamsArrayOrCollection: true } conversion ? conversion.Operand : expression); 143if (delegateNode is BoundConversion boundConversion)

Symbols\ConstantValueUtils.cs (2)

99var conversion = (BoundConversion)unconvertedBoundValue;

Symbols\Source\ParameterHelpers.cs (2)

1095var conversion = (BoundConversion)expression;

Symbols\Source\SourceComplexParameterSymbol.cs (1)

408((BoundConversion)convertedExpression).ConversionKind != ConversionKind.DefaultLiteral)