BoundConversion

Binder\Binder.ValueChecks.cs (10)

786var conversion = (BoundConversion)expr; 3689Debug.Assert(expr is BoundConversion conversion && 4054var conversion = (BoundConversion)expr; 4428var conversion = (BoundConversion)expr; 5214var conversion = (BoundConversion)expr; 5624private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundConversion conversion, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)

Binder\Binder_Attributes.cs (2)

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

Binder\Binder_Conversions.cs (2)

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

Binder\Binder_Deconstruct.cs (1)

161var boundConversion = new BoundConversion(

Binder\Binder_Expressions.cs (4)

5142case BoundConversion { Conversion.IsIdentity: true, Operand: BoundParameter param }: 5967if (argument is BoundConversion { Conversion.IsInterpolatedStringHandler: true, Operand: var operand }) 7506leftSymbol = ((BoundConversion)boundValue).Operand.ExpressionSymbol; 9630else if (convertedIndex is BoundConversion { Operand: { ConstantValueOpt: { SpecialType: SpecialType.System_Int32, Int32Value: int constIndex } } operand })

Binder\Binder_Operators.cs (8)

71var conversion = (BoundConversion)CreateConversion(node, placeholder, finalDynamicConversion, isCast: true, conversionGroupOpt: null, left.Type, diagnostics); 270if (finalConversion is not BoundConversion final) 2767BoundConversion leftConv = (BoundConversion)left; 2768BoundConversion rightConv = (BoundConversion)right; 3216if (resultConversion is not BoundConversion)

Binder\Binder_Patterns.cs (2)

689var conversion = (BoundConversion)convertedExpression;

Binder\Binder_Query.cs (2)

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

Binder\Binder_Statements.cs (2)

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

Binder\ForEachLoopBinder.cs (1)

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

Binder\RefSafetyAnalysis.cs (4)

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

BoundTree\BoundExpression.cs (1)

485public BoundConversion UpdateOperand(BoundExpression operand)

BoundTree\BoundExpressionExtensions.cs (2)

245BoundConversion 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)

320case BoundConversion conversion:

BoundTree\BoundTreeVisitors.cs (1)

64return VisitConversion(node as BoundConversion, arg);

BoundTree\Constructors.cs (2)

328public static BoundConversion SynthesizedNonUserDefined(SyntaxNode syntax, BoundExpression operand, Conversion conversion, TypeSymbol type, ConstantValue? constantValueOpt = null) 348public 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); 1233var conversion = (BoundConversion)receiver; 1273if (receiver.Kind == BoundKind.Conversion && ((BoundConversion)receiver).ConversionKind == ConversionKind.Unboxing) 1536var conversion = (BoundConversion)receiver; 2166BoundConversion conv = (BoundConversion)current; 3918var 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 (15)

2114else if ((highestBoundExpr as BoundConversion)?.Conversion.IsTupleLiteralConversion == true) 2116var tupleLiteralConversion = (BoundConversion)highestBoundExpr; 2142if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.SwitchExpression, Conversion: var convertedSwitchConversion }) 2160if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.ConditionalExpression }) 2179if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.CollectionExpression or ConversionKind.NoConversion, Conversion: var convertedCollectionConversion }) 2185else if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.ImplicitNullable, Conversion.UnderlyingConversions: [{ Kind: ConversionKind.CollectionExpression }] } boundConversion) 2206else if (((BoundConversion)highestBoundExpr).Operand.Kind != BoundKind.Conversion) 2221conversion = binder.Conversions.ClassifyConversionFromExpression(boundExpr, convertedType, isChecked: ((BoundConversion)highestBoundExpr).Checked, ref discardedUseSiteInfo); 2253else if (boundExpr is BoundConversion { ConversionKind: ConversionKind.MethodGroup, Conversion: var exprConversion, Type: { TypeKind: TypeKind.FunctionPointer }, SymbolOpt: var symbol }) 3536var conversion = (BoundConversion)boundNode; 4307var conversion = (BoundConversion)boundNodeForSyntacticParent; 4314else if (conversion.Operand is BoundConversion { ConversionKind: ConversionKind.MethodGroup } nestedMethodGroupConversion)

Compilation\MemberSemanticModel.cs (2)

1006var boundConversion = boundDeconstruction.Right; 1808node = ((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)

1740public override BoundNode VisitConversion(BoundConversion node) 1767protected 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)

928BoundConversion boundConversion = (BoundConversion)value; 2818protected override void AfterVisitConversion(BoundConversion node)

FlowAnalysis\NullableWalker.cs (41)

253/// 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>)"/>. 2133var conv = (BoundConversion)node; 2590var conversion = (BoundConversion)expr; 4041if (node.Conversion is BoundConversion { Conversion: var conversion }) 4845var expression = GetConversionIfApplicable(expressions[i], expressionNoConversion); 5342expr as BoundConversion, 5455expr as BoundConversion, 5609operand = ((BoundConversion)operand).Operand; 5803var conversion = (BoundConversion)possiblyConversion; 5912if ((node.RightOperand as BoundConversion)?.ExplicitCastInCode != false && 5966if (node is BoundConversion boundConversion) 6068Debug.Assert(innerCondAccess.Receiver is not (BoundConditionalAccess or BoundConversion)); 7403TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState.Create(argument.Type, result.RValueType.State), argument as BoundConversion, argumentNoConversion); 7461elements = ((BoundCollectionExpression)((BoundConversion)argument).Operand).UnconvertedCollectionExpression.Elements.CastArray<BoundExpression>(); 7799BoundConversion? conversionOpt, 8544var conversion = (BoundConversion)expr; 8755public override BoundNode? VisitConversion(BoundConversion node) 9016BoundConversion? conversionOpt, 9240private static BoundConversion? GetConversionIfApplicable(BoundExpression? conversionOpt, BoundExpression convertedNode) 9247return conversionOpt == convertedNode ? null : (BoundConversion?)conversionOpt; 9270BoundConversion? conversionOpt, 9451if (useLegacyWarnings && conversionOperand is BoundConversion operandConversion && !operandConversion.ConversionKind.IsUserDefinedConversion()) 9822BoundConversion? conversionOpt, 9974var conversionOpt = conversionExpression as BoundConversion; 9982conversionOpt = conversionOpt.Operand as BoundConversion; 9986private void TrackAnalyzedNullabilityThroughConversionGroup(TypeWithState resultType, BoundConversion? conversionOpt, BoundExpression convertedNode) 10002conversionOpt = conversionOpt.Operand as BoundConversion; 10627var right = node.Right; 10909var conv = (BoundConversion)expr; 11026if (node.OperandConversion is BoundConversion { Conversion: var operandConversion } && operandConversion.IsUserDefined && operandConversion.Method?.ParameterCount == 1) 11209node.LeftConversion as BoundConversion ?? node.Left, 11707if (!reportedDiagnostic && !(collectionExpression is BoundConversion { Operand: { IsSuppressed: true } })) 11795if (node.Expression is not BoundConversion { Operand.IsSuppressed: true } && 11832isSuppressed: node.Expression is BoundConversion { Operand.IsSuppressed: true }, 11958node.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)

1848public BoundDeconstructionAssignmentOperator(SyntaxNode syntax, BoundTupleExpression left, BoundConversion right, bool isUsed, TypeSymbol type, bool hasErrors = false) 1863public BoundConversion Right { get; } 1869public BoundDeconstructionAssignmentOperator Update(BoundTupleExpression left, BoundConversion right, bool isUsed, TypeSymbol type) 2973public BoundConversion Update(BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, TypeSymbol type) 2977var result = new BoundConversion(this.Syntax, operand, conversion, isBaseConversion, @checked, explicitCastInCode, constantValueOpt, conversionGroupOpt, type, this.HasErrors); 9007return VisitConversion((BoundConversion)node, arg); 9405public virtual R VisitConversion(BoundConversion node, A arg) => this.DefaultVisit(node, arg); 9641public virtual BoundNode? VisitConversion(BoundConversion node) => this.DefaultVisit(node); 10067public override BoundNode? VisitConversion(BoundConversion node) 11113BoundConversion right = (BoundConversion)this.Visit(node.Right); 11304public override BoundNode? VisitConversion(BoundConversion node) 12960BoundConversion right = (BoundConversion)this.Visit(node.Right); 13418public override BoundNode? VisitConversion(BoundConversion node) 13421BoundConversion updatedNode; 15777public override TreeDumperNode VisitConversion(BoundConversion node, object? arg) => new TreeDumperNode("conversion", null, new TreeDumperNode[]

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

153public override BoundNode? VisitConversion(BoundConversion node)

Lowering\ClosureConversion\ClosureConversion.cs (1)

1392public override BoundNode VisitConversion(BoundConversion conversion)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (6)

204return VisitConversion((BoundConversion)node); 535var conversion = (BoundConversion)operand; 669var conversion = e as BoundConversion; 686private 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)

1117return 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)

722var conversion = (BoundConversion)expression;

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

583BoundConversion conv = (BoundConversion)current; 852if (argument is BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler, Operand: BoundInterpolatedString or BoundBinaryOperator } conversion) 860Debug.Assert(!((BoundConversion)argument).ExplicitCastInCode); 925if (argument is BoundConversion { ConversionKind: ConversionKind.InterpolatedStringHandler, Operand: BoundInterpolatedString or BoundBinaryOperator } conversion) 931Debug.Assert(!((BoundConversion)argument).ExplicitCastInCode); 1426=> expr is BoundConversion conv && conv.ConversionKind == ConversionKind.AnonymousFunction;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (4)

663var spreadElementHasIdentityConversion = expressionStatement.Expression is not BoundConversion; 945if (spreadElement.IteratorBody is not BoundExpressionStatement expressionStatement || expressionStatement.Expression is BoundConversion) 1327var convertedExpression = (BoundConversion?)node.Conversion;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (2)

967var 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)

124(BoundConversion)node.Expression, 138BoundConversion convertedCollection, 1214var boundConversion = (BoundConversion)node.Expression;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

722else 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 (4)

222not (BoundCall or BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand.Type.SpecialType: SpecialType.System_Char }) 286if (argument is BoundConversion { ConversionKind: ConversionKind.Boxing, Type.SpecialType: SpecialType.System_Object, Operand: { Type.SpecialType: SpecialType.System_Char } operand }) 582BoundConversion 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)

755while (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)

1174public 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; 1978boundForEachStatement.Expression is not BoundConversion { Conversion.IsIdentity: true, ExplicitCastInCode: false, Operand: BoundExpression operand } ? 2355BoundConversion { Operand: BoundLiteral } c => CreateBoundConversionOperation(c, forceOperandImplicitLiteral: true), 2417private 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)

1087var conversion = (BoundConversion)expression;

Symbols\Source\SourceComplexParameterSymbol.cs (1)

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