343conversion = new Conversion(ConversionKind.Deconstruction, deconstructMethod, nestedConversions.ToImmutableAndFree());

134return new Conversion( 197return new Conversion(this.Kind, conversionMethod, isExtensionMethod: IsExtensionMethod); 205return new Conversion( 263return new Conversion(kind); 266internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 267internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 268internal static Conversion Identity => new Conversion(ConversionKind.Identity); 269internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 270internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 271internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 272internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 273internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 274internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 275internal static Conversion CollectionExpression => new Conversion(ConversionKind.CollectionExpression); 276internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 277internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 278internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 279internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 280internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 281internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 282internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 283internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 284internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 285internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 286internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 287internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 288internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 289internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 290internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 291internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 292internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 293internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 294internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 295internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 296internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 297internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 298internal static Conversion InlineArray => new Conversion(ConversionKind.InlineArray); 299internal static Conversion ImplicitSpan => new Conversion(ConversionKind.ImplicitSpan); 300internal static Conversion ExplicitSpan => new Conversion(ConversionKind.ExplicitSpan); 312internal static readonly Conversion ExplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitEnumerationUnderlying); 313internal static readonly Conversion ExplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ExplicitNullable, PointerToIntegerUnderlying); 314internal static readonly Conversion ExplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ExplicitNullable, IdentityUnderlying); 315internal static readonly Conversion ExplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitNumericUnderlying); 316internal static readonly Conversion ExplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitNumericUnderlying); 317internal static readonly Conversion ExplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitConstantUnderlying); 319internal static readonly Conversion ImplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitEnumerationUnderlying); 320internal static readonly Conversion ImplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ImplicitNullable, PointerToIntegerUnderlying); 321internal static readonly Conversion ImplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ImplicitNullable, IdentityUnderlying); 322internal static readonly Conversion ImplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitNumericUnderlying); 323internal static readonly Conversion ImplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitNumericUnderlying); 324internal static readonly Conversion ImplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitConstantUnderlying); 340return new Conversion(ConversionKind.StackAllocToPointerType, ImmutableArray.Create(underlyingConversion)); 345return new Conversion(ConversionKind.StackAllocToSpanType, ImmutableArray.Create(underlyingConversion)); 360_ => new Conversion(kind, ImmutableArray.Create(nestedConversion)), 366return new Conversion(ConversionKind.SwitchExpression, innerConversions); 371return new Conversion(ConversionKind.ConditionalExpression, innerConversions);

504return new Conversion(ConversionKind.MethodGroup, method, isExtensionMethod: isExtensionMethod);

785return new Conversion(conversionResult, isImplicit: true); 875return new Conversion(conversionResult, isImplicit: false); 1176return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingConversion)); 1312return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1341return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1748return new Conversion(result, isImplicit: true); 2273return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(tupleConversion)); 2355return new Conversion(kind, argumentConversions.ToImmutableAndFree()); 2428return new Conversion(kind, nestedConversions.ToImmutableAndFree()); 2470return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(tupleConversion));

2099conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, false); 2220conversion = new Conversion(ConversionKind.MethodGroup, delegateCreation.MethodOpt, delegateCreation.IsExtensionMethod); 2226conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, delegateCreation.IsExtensionMethod); 2232conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, delegateCreation.IsExtensionMethod);

1144var userDefinedConversion = new Conversion(conversionKind, method, false); 1757var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1805var resultConversion = new Conversion(result, conversion.IsImplicit); 1905return new Conversion(result, isImplicit);

29139var expectedConversion = new Conversion(ConversionKind.CollectionExpression, nestedConversions: ImmutableArray.Create(Conversion.Identity, Conversion.Identity));

527Conversion conversion = _typeSymbols.Compilation.ClassifyConversion(source, dest);

173var conversion = compilation.ClassifyConversion(symbols.IComponentType, type);

102var conversion = context.Compilation.ClassifyConversion(symbols.ParameterCaptureUnmatchedValuesRuntimeType, property.Type);

89var conversion = context.Compilation.ClassifyConversion(propertyContainingType, assignmentContainingType);

102var conversion = compilation.ClassifyConversion(symbols.IComponentType, type);

96var conversion = context.Compilation.ClassifyConversion(symbols.ParameterCaptureUnmatchedValuesRuntimeType, property.Type);

89var conversion = context.Compilation.ClassifyConversion(propertyContainingType, assignmentContainingType);

624internal void ReportDiagnosticsIfObsolete(BindingDiagnosticBag diagnostics, Conversion conversion, SyntaxNodeOrToken node, bool hasBaseReceiver)

4248if (conversion.Conversion == Conversion.ImplicitThrow)

360if (!isApplicableMethod(exprType, member, node, diagnostics, this, out MethodSymbol? method, out Conversion argumentConversion)) 416out Conversion conversion) 469static bool isValidConversion(TypeSymbol exprType, MethodSymbol method, SyntaxNode node, BindingDiagnosticBag diagnostics, Binder @this, out Conversion conversion) 677var conversion = this.Conversions.ClassifyImplicitConversionFromType(awaiterType, INotifyCompletion, ref useSiteInfo);

26var conversion = Conversions.ClassifyConversionFromExpression(source, destination, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 34Conversion conversion, 44Conversion conversion, 57Conversion conversion, 84static bool filterConversion(Conversion conversion) 100Conversion conversion, 315void reportUseSiteDiagnostics(SyntaxNode syntax, Conversion conversion, BoundExpression source, TypeSymbol destination, BindingDiagnosticBag diagnostics) 329void ensureAllUnderlyingConversionsChecked(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool wasCompilerGenerated, TypeSymbol destination, BindingDiagnosticBag diagnostics) 426void checkConstraintLanguageVersionAndRuntimeSupportForConversion(SyntaxNode syntax, Conversion conversion, BoundExpression source, TypeSymbol destination, BindingDiagnosticBag diagnostics) 761SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, Conversion conversion, bool isCast, TypeSymbol destination, 783expr is BoundBadExpression ? Conversion.NoConversion : conversion, 830Conversion conversion, 972var elementConversion = elementConversions[i]; 1007BoundNode bindSpreadElement(BoundCollectionExpressionSpreadElement element, TypeSymbol elementType, Conversion elementConversion, BindingDiagnosticBag diagnostics) 1069Conversion collectionBuilderReturnTypeConversion; 1578var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 1824Conversion elementConversion = Conversions.GetCollectionExpressionSpreadElementConversion(spreadElement, elementType, ref useSiteInfo); 1834Conversion elementConversion = Conversions.ClassifyImplicitConversionFromExpression((BoundExpression)element, elementType, ref useSiteInfo); 1859out Conversion returnTypeConversion) 1916var conversion = Conversions.ClassifyImplicitConversionFromType(elementTypeOriginalDefinition, spanTypeArg, ref candidateUseSiteInfo); 1947Conversion? conversionIfTargetTyped, 1953var conversion = conversionIfTargetTyped.GetValueOrDefault(); 1954ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions; 1987private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, Conversion? conversionIfTargetTyped, BindingDiagnosticBag diagnostics, bool hasErrors = false) 1990Conversion conversion = conversionIfTargetTyped ?? Conversion.Identity; 1992ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions; 2017Conversion conversion, 2096Conversion toParameterTypeConversion = Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo); 2117Conversion toConversion = conversion.UserDefinedToConversion; 2148Conversion fromReturnTypeConversion = Conversions.ClassifyStandardConversion(conversionReturnType, conversionToType, ref useSiteInfo); 2204SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2265SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2296SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2457SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2483var underlyingConversion = conversion.UnderlyingConversions.Single(); 2488SyntaxNode syntax, BoundTupleLiteral sourceTuple, Conversion conversion, bool isCast, 2500var conversionWithoutNullable = conversion; 2555var elementConversion = underlyingConversions[i]; 2593Conversion.Identity, 2615private BoundMethodGroup FixMethodGroupWithTypeOrValue(BoundMethodGroup group, Conversion conversion, BindingDiagnosticBag diagnostics) 3066Conversion conversion, 3133out Conversion conversion) 3137conversion = Conversion.NoConversion; 3165Conversion conversion,

132new BoundConversion(boundRHS.Syntax, boundRHS, Conversion.Deconstruction, @checked: false, explicitCastInCode: false, 139Conversion conversion; 249out Conversion conversion) 253conversion = Conversion.Deconstruction; 301Conversion nestedConversion;

184return FixMethodGroupWithTypeOrValue(methodGroup, Conversion.NoConversion, BindingDiagnosticBag.Discarded); 1261Conversion conversion = this.Conversions.ClassifyConversionFromExpression(argument, typedReferenceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1310Conversion conversion = this.Conversions.ClassifyConversionFromExpression(argument, typedReferenceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 2704Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, intType, ref useSiteInfo); 2810Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, indexType, ref useSiteInfo); 2825Conversion conversion = this.Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 2842Conversion conversion, 2983var elementConversion = Conversions.ClassifyConversionFromExpression(argument, targetElementType, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3009var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3568var kind = result.ConversionForArg(arg); 3750var interpolatedStringConversion = result.ConversionForArg(interpolatedStringArgNum); 5394var conversion = @this.Conversions.ClassifyConversionFromExpression(expression, collectionType, isChecked: @this.CheckOverflowAtRuntime, ref useSiteInfo); 5486var conversion = this.Conversions.ClassifyConversionFromExpression(unboundLambda, type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5526Conversion conversion; 5559Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 7098Conversion conversion = this.Conversions.ClassifyConversionFromExpression(classCreation, interfaceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 9119Conversion.ImplicitNumeric, 9956Conversion failedConversion = this.Conversions.ClassifyConversionFromExpression(index, int32, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 10011Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(expr, targetType, ref useSiteInfo);

1746Conversion conversion = Conversions.ClassifyConversionFromExpression(defaultValue, parameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1861Conversion conversion = Conversions.ClassifyImplicitConversionFromExpression(unconvertedCollection, collectionType, ref useSiteInfo);

76var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 298Conversion rightToLeftConversion = this.Conversions.ClassifyConversionFromExpression(right, leftType, isChecked: checkOverflowAtRuntime, ref useSiteInfo); 501Conversion conversion = overloadResolutionResult.ValidResult.Result.ConversionForArg(0); 705Conversion argumentConversion = this.Conversions.ClassifyConversionFromExpression(right, delegateType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1319var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 1615var implicitConversion = Conversions.ClassifyImplicitConversionFromExpression(left, booleanType, ref useSiteInfo); 3589Conversion conversion = overloadResolutionResult.ValidResult.Result.ConversionForArg(0); 4910Conversion conv = Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 4932Conversion conversion = Conversions.ClassifyBuiltInConversion(operandType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5389Conversion.NullLiteral, 5428Conversion conversion = Conversions.ClassifyBuiltInConversion(operandType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5671var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType0, ref useSiteInfo); 5689var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType, ref useSiteInfo); 5726Conversion leftConversionClassification; 5804var underlyingRightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, underlyingLeftType, ref useSiteInfo); 5818var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, leftType, ref useSiteInfo);

436var convertedExpression = BindExpressionOrTypeForPattern(inputType, innerExpression, ref hasErrors, diagnostics, out var constantValueOpt, out bool wasExpression, out Conversion patternConversion); 465private bool ShouldBlockINumberBaseConversion(Conversion patternConversion, TypeSymbol inputType) 516out Conversion patternExpressionConversion) 529patternExpressionConversion = Conversion.NoConversion; 544out Conversion patternExpressionConversion) 550patternExpressionConversion = Conversion.NoConversion; 561out Conversion patternExpressionConversion) 606out Conversion patternExpressionConversion) 652patternExpressionConversion = Conversion.NoConversion; 659patternExpressionConversion = Conversion.NoConversion; 688patternExpressionConversion = Conversion.NoConversion; 778Conversions, inputType, patternType, ref useSiteInfo, out Conversion conversion, operandConstantValue: null, operandCouldBeNull: true); 819out Conversion conversion, 829conversion = Conversion.Identity; 1643BoundExpression value = BindExpressionForPattern(inputType, node.Expression, ref hasErrors, diagnostics, out var constantValueOpt, out _, out Conversion patternConversion);

1372Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(pointerType, declType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1965internal BoundExpression GenerateConversionForAssignment(TypeSymbol targetType, BoundExpression expression, BindingDiagnosticBag diagnostics, out Conversion conversion, ConversionForAssignmentFlags flags = ConversionForAssignmentFlags.None) 2278Conversion conversion, TypeSymbol sourceType, TypeSymbol targetType, ConstantValue sourceConstantValueOpt = null) 2348Conversion conversion, 2470var conversion = this.Conversions.ClassifyImplicitConversionFromExpression(expr, targetType, ref useSiteInfo); 2570var elementConversion = Conversions.ClassifyImplicitConversionFromExpression(argument, targetElementType, ref discardedUseSiteInfo); 2693return BoundConversion.Synthesized(node, BindToTypeForErrorRecovery(expr), Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, ConstantValue.NotAvailable, boolean, hasErrors: true); 2718var conversion = this.Conversions.ClassifyConversionFromExpression(expr, boolean, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 2761return BoundConversion.Synthesized(node, expr, Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, InConversionGroupFlags.Unspecified, ConstantValue.NotAvailable, boolean, hasErrors: true); 3184Conversion conversion; 3193conversion = Conversion.NoConversion;

133Conversion conversion = this.Conversions.ClassifyImplicitConversionFromType(type, boolean, ref useSiteInfo);

506Conversion conversion = _conversions.ClassifyBuiltInConversion(inputType, type, isChecked: false, ref useSiteInfo); 1588ConstantValue result = Binder.ExpressionOfTypeMatchesPatternType(_conversions, expressionType, patternType, ref useSiteInfo, out Conversion conversion);

482Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 536Conversion collectionConversionClassification = this.Conversions.ClassifyConversionFromExpression(collectionExpr, builder.CollectionType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 537Conversion currentConversionClassification = this.Conversions.ClassifyConversionFromType(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 640Conversion collectionConversionClassification, 1554var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);

1121private void VisitDeconstructionArguments(ArrayBuilder<DeconstructionVariable> variables, SyntaxNode syntax, Conversion conversion, BoundExpression right) 1192var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder);

19public readonly struct Conversion : IEquatable<Conversion>, IConvertibleConversion 83public NestedUncommonData(ImmutableArray<Conversion> nestedConversions) 88internal readonly ImmutableArray<Conversion> _nestedConversionsOpt; 112ImmutableArray<Conversion> elementConversions) : 129internal static Conversion CreateCollectionExpressionConversion( 132ImmutableArray<Conversion> elementConversions) 173internal Conversion(ConversionKind kind, ImmutableArray<Conversion> nestedConversions) 188internal Conversion SetConversionMethod(MethodSymbol conversionMethod) 200internal Conversion SetArrayIndexConversionForDynamic() 260internal static Conversion GetTrivialConversion(ConversionKind kind) 266internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 267internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 268internal static Conversion Identity => new Conversion(ConversionKind.Identity); 269internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 270internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 271internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 272internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 273internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 274internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 275internal static Conversion CollectionExpression => new Conversion(ConversionKind.CollectionExpression); 276internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 277internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 278internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 279internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 280internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 281internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 282internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 283internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 284internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 285internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 286internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 287internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 288internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 289internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 290internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 291internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 292internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 293internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 294internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 295internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 296internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 297internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 298internal static Conversion InlineArray => new Conversion(ConversionKind.InlineArray); 299internal static Conversion ImplicitSpan => new Conversion(ConversionKind.ImplicitSpan); 300internal static Conversion ExplicitSpan => new Conversion(ConversionKind.ExplicitSpan); 304internal static ImmutableArray<Conversion> IdentityUnderlying => ConversionSingletons.IdentityUnderlying; 305internal static ImmutableArray<Conversion> ImplicitConstantUnderlying => ConversionSingletons.ImplicitConstantUnderlying; 306internal static ImmutableArray<Conversion> ImplicitNumericUnderlying => ConversionSingletons.ImplicitNumericUnderlying; 307internal static ImmutableArray<Conversion> ExplicitNumericUnderlying => ConversionSingletons.ExplicitNumericUnderlying; 308internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying => ConversionSingletons.ExplicitEnumerationUnderlying; 309internal static ImmutableArray<Conversion> PointerToIntegerUnderlying => ConversionSingletons.PointerToIntegerUnderlying; 312internal static readonly Conversion ExplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitEnumerationUnderlying); 313internal static readonly Conversion ExplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ExplicitNullable, PointerToIntegerUnderlying); 314internal static readonly Conversion ExplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ExplicitNullable, IdentityUnderlying); 315internal static readonly Conversion ExplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitNumericUnderlying); 316internal static readonly Conversion ExplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitNumericUnderlying); 317internal static readonly Conversion ExplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitConstantUnderlying); 319internal static readonly Conversion ImplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitEnumerationUnderlying); 320internal static readonly Conversion ImplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ImplicitNullable, PointerToIntegerUnderlying); 321internal static readonly Conversion ImplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ImplicitNullable, IdentityUnderlying); 322internal static readonly Conversion ImplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitNumericUnderlying); 323internal static readonly Conversion ImplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitNumericUnderlying); 324internal static readonly Conversion ImplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitConstantUnderlying); 330internal static ImmutableArray<Conversion> IdentityUnderlying = ImmutableArray.Create(Identity); 331internal static ImmutableArray<Conversion> ImplicitConstantUnderlying = ImmutableArray.Create(ImplicitConstant); 332internal static ImmutableArray<Conversion> ImplicitNumericUnderlying = ImmutableArray.Create(ImplicitNumeric); 333internal static ImmutableArray<Conversion> ExplicitNumericUnderlying = ImmutableArray.Create(ExplicitNumeric); 334internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying = ImmutableArray.Create(ExplicitEnumeration); 335internal static ImmutableArray<Conversion> PointerToIntegerUnderlying = ImmutableArray.Create(PointerToInteger); 338internal static Conversion MakeStackAllocToPointerType(Conversion underlyingConversion) 343internal static Conversion MakeStackAllocToSpanType(Conversion underlyingConversion) 348internal static Conversion MakeNullableConversion(ConversionKind kind, Conversion nestedConversion) 364internal static Conversion MakeSwitchExpression(ImmutableArray<Conversion> innerConversions) 369internal static Conversion MakeConditionalExpression(ImmutableArray<Conversion> innerConversions) 398internal ImmutableArray<Conversion> UnderlyingConversions 404default(ImmutableArray<Conversion>); 425foreach (var underlying in underlyingConversions) 464foreach (var underlying in underlyingConversions) 575foreach (var conv in nestedConversions) 1079internal Conversion UserDefinedFromConversion 1084return best == null ? Conversion.NoConversion : best.SourceConversion; 1091internal Conversion UserDefinedToConversion 1096return best == null ? Conversion.NoConversion : best.TargetConversion; 1147/// This is a lossy conversion; it is not possible to recover the original <see cref="Conversion"/> 1167/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1169/// <param name="obj">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1170/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1173return obj is Conversion && this.Equals((Conversion)obj); 1177/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1179/// <param name="other">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1180/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1181public bool Equals(Conversion other) 1187/// Returns a hash code for the current <see cref="Conversion"/> object. 1189/// <returns>A hash code for the current <see cref="Conversion"/> object.</returns> 1196/// Returns true if the specified <see cref="Conversion"/> objects are equal and false otherwise. 1198/// <param name="left">The first <see cref="Conversion"/> object.</param> 1199/// <param name="right">The second <see cref="Conversion"/> object.</param> 1201public static bool operator ==(Conversion left, Conversion right) 1207/// Returns false if the specified <see cref="Conversion"/> objects are equal and true otherwise. 1209/// <param name="left">The first <see cref="Conversion"/> object.</param> 1210/// <param name="right">The second <see cref="Conversion"/> object.</param> 1212public static bool operator !=(Conversion left, Conversion right) 1222TreeDumperNode Dump(Conversion self)

44public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 49return Conversion.NoConversion; 55return Conversion.NoConversion; 107var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ? 108Conversion.NoConversion : 115public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 124var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ? 125Conversion.NoConversion : 131protected override Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 137return Conversion.NoConversion; 142return Conversion.InterpolatedStringHandler; 147return Conversion.NoConversion; 155? Conversion.InterpolatedString : Conversion.NoConversion; 159protected override Conversion GetCollectionExpressionConversion( 170return Conversion.NoConversion; 179return Conversion.NoConversion; 195return Conversion.NoConversion; 201return Conversion.NoConversion; 205var builder = ArrayBuilder<Conversion>.GetInstance(elements.Length); 208Conversion elementConversion = convertElement(element, elementType, ref useSiteInfo); 212return Conversion.NoConversion; 218return Conversion.CreateCollectionExpressionConversion(collectionTypeKind, elementType, constructor, isExpanded, builder.ToImmutableAndFree()); 220Conversion convertElement(BoundNode element, TypeSymbol elementType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 230internal Conversion GetCollectionExpressionSpreadElementConversion( 238return Conversion.NoConversion; 395public Conversion MethodGroupConversion(SyntaxNode syntax, MethodGroup methodGroup, NamedTypeSymbol delegateType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 414var conversion = ToConversion(result, methodGroup, delegateType.DelegateInvokeMethod.ParameterCount); 446private static Conversion ToConversion(OverloadResolutionResult<MethodSymbol> result, MethodGroup methodGroup, int parameterCount) 466return Conversion.NoConversion; 475return Conversion.NoConversion; 482return Conversion.NoConversion; 487return Conversion.NoConversion; 507public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 515var pointerConversion = ClassifyImplicitConversionFromType(sourceAsPointer, destination, ref useSiteInfo); 519return Conversion.MakeStackAllocToPointerType(pointerConversion); 527var spanConversion = ClassifyImplicitConversionFromType(spanType_T, destination, ref useSiteInfo); 531return Conversion.MakeStackAllocToSpanType(spanConversion); 537return Conversion.NoConversion;

67public abstract Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 69public abstract Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 71public abstract Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 75protected abstract Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 78protected abstract Conversion GetCollectionExpressionConversion(BoundUnconvertedCollectionExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 98public Conversion ClassifyImplicitConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 109return Conversion.Identity; 112Conversion conversion = ClassifyImplicitBuiltInConversionFromExpression(sourceExpression, sourceType, destination, ref useSiteInfo); 121Conversion fastConversion = FastClassifyConversion(sourceType, destination); 142return Conversion.FunctionType; 169public Conversion ClassifyImplicitConversionFromType(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 177return Conversion.Identity; 181Conversion fastConversion = FastClassifyConversion(source, destination); 184return fastConversion.IsImplicit ? fastConversion : Conversion.NoConversion; 188Conversion conversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 204public Conversion ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 217Conversion.FunctionType : 218Conversion.NoConversion; 222return Conversion.NoConversion; 234public Conversion ClassifyConversionFromExpressionType(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 242return Conversion.ImplicitDynamic; 248private static bool TryGetVoidConversion(TypeSymbol source, TypeSymbol destination, out Conversion conversion) 259conversion = Conversion.Identity; 266conversion = Conversion.NoConversion; 283public Conversion ClassifyConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast = false) 289if (TryGetVoidConversion(sourceExpression.Type, destination, out var conversion)) 299var result = ClassifyImplicitConversionFromExpression(sourceExpression, destination, ref useSiteInfo); 317public Conversion ClassifyConversionFromType(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast = false) 322if (TryGetVoidConversion(source, destination, out var voidConversion)) 333Conversion fastConversion = FastClassifyConversion(source, destination); 340Conversion conversion1 = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 347Conversion conversion = GetImplicitUserDefinedConversion(source, destination, ref useSiteInfo); 375private Conversion ClassifyConversionFromExpressionForCast(BoundExpression source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 381Conversion implicitConversion = ClassifyImplicitConversionFromExpression(source, destination, ref useSiteInfo); 387Conversion explicitConversion = ClassifyExplicitOnlyConversionFromExpression(source, destination, isChecked: isChecked, ref useSiteInfo, forCast: true); 429private Conversion ClassifyConversionFromTypeForCast(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 435Conversion fastConversion = FastClassifyConversion(source, destination); 441Conversion implicitBuiltInConversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 447Conversion explicitBuiltInConversion = ClassifyExplicitBuiltInOnlyConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast: true); 474var conversion = GetExplicitUserDefinedConversion(source, destination, isChecked: isChecked, ref useSiteInfo); 488public static Conversion FastClassifyConversion(TypeSymbol source, TypeSymbol target) 493return Conversion.GetTrivialConversion(convKind); 496return Conversion.MakeNullableConversion(convKind, FastClassifyConversion(source.StrippedType(), target.StrippedType())); 499public Conversion ClassifyBuiltInConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 505Conversion fastConversion = FastClassifyConversion(source, destination); 512Conversion conversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 529public Conversion ClassifyStandardConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 541public Conversion ClassifyStandardConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 569Conversion conversion = ClassifyStandardImplicitConversion(sourceExpression, source, destination, ref useSiteInfo); 580return Conversion.NoConversion; 605private Conversion ClassifyStandardImplicitConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 642Conversion conversion = ClassifyImplicitBuiltInConversionFromExpression(sourceExpression, source, destination, ref useSiteInfo); 656return Conversion.NoConversion; 658static bool isImplicitCollectionExpressionConversion(Conversion conversion) 695private Conversion ClassifyStandardImplicitConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 697var conversion = classifyConversion(source, destination, ref useSiteInfo); 701Conversion classifyConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 708return Conversion.Identity; 713return Conversion.ImplicitNumeric; 716var nullableConversion = ClassifyImplicitNullableConversion(source, destination, ref useSiteInfo); 725return Conversion.NoConversion; 730return Conversion.ImplicitReference; 735return Conversion.Boxing; 740return Conversion.PointerToVoid; 745return Conversion.ImplicitPointer; 748var tupleConversion = ClassifyImplicitTupleConversion(source, destination, ref useSiteInfo); 756return Conversion.ImplicitSpan; 759return Conversion.NoConversion; 763private Conversion ClassifyImplicitBuiltInConversionSlow(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 770return Conversion.NoConversion; 773Conversion conversion = ClassifyStandardImplicitConversion(source, destination, ref useSiteInfo); 779return Conversion.NoConversion; 782private Conversion GetImplicitUserDefinedConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 788private Conversion GetImplicitUserDefinedConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 793private Conversion ClassifyExplicitBuiltInOnlyConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 800return Conversion.NoConversion; 814return Conversion.IntPtr; 819return Conversion.ExplicitEnumeration; 822var nullableConversion = ClassifyExplicitNullableConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 830return (source.Kind == SymbolKind.DynamicType) ? Conversion.ExplicitDynamic : Conversion.ExplicitReference; 835return Conversion.Unboxing; 838var tupleConversion = ClassifyExplicitTupleConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 846return Conversion.PointerToPointer; 851return Conversion.PointerToInteger; 856return Conversion.IntegerToPointer; 861return Conversion.ExplicitDynamic; 866return Conversion.ExplicitSpan; 869return Conversion.NoConversion; 872private Conversion GetExplicitUserDefinedConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 878private Conversion GetExplicitUserDefinedConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 883private Conversion DeriveStandardExplicitFromOppositeStandardImplicitConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 885var oppositeConversion = ClassifyStandardImplicitConversion(destination, source, ref useSiteInfo); 886Conversion impliedExplicitConversion; 891impliedExplicitConversion = Conversion.Identity; 894impliedExplicitConversion = Conversion.ExplicitNumeric; 897impliedExplicitConversion = Conversion.ExplicitReference; 900impliedExplicitConversion = Conversion.Unboxing; 903impliedExplicitConversion = Conversion.NoConversion; 906impliedExplicitConversion = Conversion.PointerToPointer; 912impliedExplicitConversion = Conversion.NoConversion; 918var underlyingConversion = DeriveStandardExplicitFromOppositeStandardImplicitConversion(strippedSource, strippedDestination, ref useSiteInfo); 923Conversion.MakeNullableConversion(ConversionKind.ExplicitNullable, underlyingConversion) : 924Conversion.NoConversion; 929impliedExplicitConversion = Conversion.NoConversion; 1010private static bool ExplicitConversionMayDifferFromImplicit(Conversion implicitConversion) 1029private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1038return Conversion.ImplicitDynamic; 1045return Conversion.NoConversion; 1050return Conversion.ImplicitEnumeration; 1053var constantConversion = ClassifyImplicitConstantExpressionConversion(sourceExpression, destination); 1062var nullLiteralConversion = ClassifyNullLiteralConversion(sourceExpression, destination); 1070return Conversion.DefaultLiteral; 1075var innerConversion = ClassifyImplicitBuiltInConversionFromExpression(innerExpression, innerExpression.Type, destination, ref useSiteInfo); 1083var tupleConversion = ClassifyImplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, ref useSiteInfo); 1093return Conversion.AnonymousFunction; 1098Conversion methodGroupConversion = GetMethodGroupDelegateConversion((BoundMethodGroup)sourceExpression, destination, ref useSiteInfo); 1107Conversion interpolatedStringConversion = GetInterpolatedStringConversion(sourceExpression, destination, ref useSiteInfo); 1114var stackAllocConversion = GetStackAllocConversion((BoundStackAllocArrayCreation)sourceExpression, destination, ref useSiteInfo); 1122var addressOfConversion = GetMethodGroupFunctionPointerConversion(((BoundUnconvertedAddressOfOperator)sourceExpression).Operand, funcPtrType, ref useSiteInfo); 1130return Conversion.ImplicitThrow; 1133return Conversion.ObjectCreation; 1136var collectionExpressionConversion = GetImplicitCollectionExpressionConversion((BoundUnconvertedCollectionExpression)sourceExpression, destination, ref useSiteInfo); 1152return Conversion.InlineArray; 1155return Conversion.NoConversion; 1159private Conversion GetImplicitCollectionExpressionConversion(BoundUnconvertedCollectionExpression collectionExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1161var collectionExpressionConversion = GetCollectionExpressionConversion(collectionExpression, destination, ref useSiteInfo); 1173var underlyingConversion = GetCollectionExpressionConversion(collectionExpression, underlyingDestination, ref useSiteInfo); 1180return Conversion.NoConversion; 1184private Conversion GetSwitchExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1192return Conversion.NoConversion; 1194var innerConversions = ArrayBuilder<Conversion>.GetInstance(switchExpression.SwitchArms.Length); 1197var nestedConversion = this.ClassifyImplicitConversionFromExpression(arm.Value, destination, ref useSiteInfo); 1201return Conversion.NoConversion; 1207return Conversion.MakeSwitchExpression(innerConversions.ToImmutableAndFree()); 1209return Conversion.NoConversion; 1213private Conversion GetConditionalExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1218return Conversion.NoConversion; 1220var trueConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Consequence, destination, ref useSiteInfo); 1222return Conversion.NoConversion; 1224var falseConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Alternative, destination, ref useSiteInfo); 1226return Conversion.NoConversion; 1228return Conversion.MakeConditionalExpression(ImmutableArray.Create(trueConversion, falseConversion)); 1231private static Conversion ClassifyNullLiteralConversion(BoundExpression source, TypeSymbol destination) 1238return Conversion.NoConversion; 1246return Conversion.NullLiteral; 1256return Conversion.ImplicitReference; 1264return Conversion.NullToPointer; 1267return Conversion.NoConversion; 1270private static Conversion ClassifyImplicitConstantExpressionConversion(BoundExpression source, TypeSymbol destination) 1274return Conversion.ImplicitConstant; 1286return Conversion.ImplicitNullableWithImplicitConstantUnderlying; 1290return Conversion.NoConversion; 1293private Conversion ClassifyImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1297var tupleConversion = GetImplicitTupleLiteralConversion(source, destination, ref useSiteInfo); 1309var underlyingTupleConversion = GetImplicitTupleLiteralConversion(source, underlyingDestination, ref useSiteInfo); 1316return Conversion.NoConversion; 1319private Conversion ClassifyExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1323var tupleConversion = GetExplicitTupleLiteralConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1337var underlyingTupleConversion = GetExplicitTupleLiteralConversion(source, underlyingDestination, isChecked: isChecked, ref useSiteInfo, forCast); 1346return Conversion.NoConversion; 1401private Conversion ClassifyExplicitOnlyConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1412Conversion tupleConversion = ClassifyExplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1423Conversion fastConversion = FastClassifyConversion(sourceType, destination); 1430var conversion = ClassifyExplicitBuiltInOnlyConversion(sourceType, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1719internal Conversion ClassifyImplicitUserDefinedConversionForV6SwitchGoverningType(TypeSymbol sourceType, out TypeSymbol switchGoverningType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1751internal Conversion GetCallerLineNumberConversion(TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1764return Conversion.ImplicitEnumeration; 1767var constantConversion = ClassifyImplicitConstantExpressionConversion(intMaxValueLiteral, destination); 1784Conversion conversion = ClassifyStandardImplicitConversion(expectedAttributeType, destination, ref useSiteInfo); 1910public Conversion ConvertExtensionMethodThisArg(TypeSymbol parameterType, TypeSymbol thisType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool isMethodGroupConversion) 1913var conversion = this.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, thisType, parameterType, ref useSiteInfo, isMethodGroupConversion); 1914return IsValidExtensionMethodThisArgConversion(conversion) ? conversion : Conversion.NoConversion; 1920public Conversion ClassifyImplicitExtensionMethodThisArgConversion(BoundExpression sourceExpressionOpt, TypeSymbol sourceType, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool isMethodGroupConversion) 1930return Conversion.Identity; 1935return Conversion.Boxing; 1940return Conversion.ImplicitReference; 1945return Conversion.ImplicitSpan; 1954var tupleConversion = GetTupleLiteralConversion( 1971var tupleConversion = ClassifyTupleConversion( 1980return Conversion.NoConversion; 1992return Conversion.NoConversion; 2001public static bool IsValidExtensionMethodThisArgConversion(Conversion conversion) 2014foreach (var elementConversion in conversion.UnderlyingConversions) 2236private Conversion ClassifyImplicitNullableConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2249return Conversion.NoConversion; 2257return Conversion.NoConversion; 2262return Conversion.ImplicitNullableWithIdentityUnderlying; 2267return Conversion.ImplicitNullableWithImplicitNumericUnderlying; 2270var tupleConversion = ClassifyImplicitTupleConversion(unwrappedSource, unwrappedDestination, ref useSiteInfo); 2276return Conversion.NoConversion; 2279private delegate Conversion ClassifyConversionFromExpressionDelegate(ConversionsBase conversions, BoundExpression sourceExpression, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2280private delegate Conversion ClassifyConversionFromTypeDelegate(ConversionsBase conversions, TypeWithAnnotations source, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2282private Conversion GetImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2300private Conversion GetExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2318private Conversion GetTupleLiteralConversion( 2334return Conversion.NoConversion; 2341var argumentConversions = ArrayBuilder<Conversion>.GetInstance(arguments.Length); 2345var result = classifyConversion(this, argument, targetElementTypes[i], isChecked: isChecked, ref useSiteInfo, forCast: forCast); 2349return Conversion.NoConversion; 2358private Conversion ClassifyImplicitTupleConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2369return Conversion.NoConversion; 2377private Conversion ClassifyExplicitTupleConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2388return Conversion.NoConversion; 2396private Conversion ClassifyTupleConversion( 2412return Conversion.NoConversion; 2415var nestedConversions = ArrayBuilder<Conversion>.GetInstance(sourceTypes.Length); 2418var conversion = classifyConversion(this, sourceTypes[i], destTypes[i], isChecked: isChecked, ref useSiteInfo, forCast); 2422return Conversion.NoConversion; 2431private Conversion ClassifyExplicitNullableConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2446return Conversion.NoConversion; 2454return Conversion.ExplicitNullableWithIdentityUnderlying; 2459return Conversion.ExplicitNullableWithImplicitNumericUnderlying; 2464return Conversion.ExplicitNullableWithExplicitNumericUnderlying; 2467var tupleConversion = ClassifyExplicitTupleConversion(unwrappedSource, unwrappedDestination, isChecked: isChecked, ref useSiteInfo, forCast); 2475return Conversion.ExplicitNullableWithExplicitEnumerationUnderlying; 2480return Conversion.ExplicitNullableWithPointerToIntegerUnderlying; 2483return Conversion.NoConversion;

36public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 42public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 48public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 54protected override Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 60protected override Conversion GetCollectionExpressionConversion(BoundUnconvertedCollectionExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

26public readonly Conversion SourceConversion; 27public readonly Conversion TargetConversion; 33Conversion sourceConversion, 34Conversion targetConversion, 51Conversion sourceConversion, 52Conversion targetConversion, 70Conversion sourceConversion, 71Conversion targetConversion,

273Conversion fromConversion = EncompassingExplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo); 274Conversion toConversion = EncompassingExplicitConversion(convertsTo, target, ref useSiteInfo); 325Conversion liftedFromConversion = EncompassingExplicitConversion(sourceExpression, source, nullableFrom, ref useSiteInfo); 326Conversion liftedToConversion = EncompassingExplicitConversion(nullableTo, target, ref useSiteInfo); 479private Conversion EncompassingExplicitConversion(BoundExpression expr, TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 498var result = ClassifyStandardConversion(expr, a, b, ref useSiteInfo); 499return result.IsEnumeration ? Conversion.NoConversion : result; 502private Conversion EncompassingExplicitConversion(TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

302Conversion fromConversion = EncompassingImplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo); 303Conversion toConversion = allowAnyTarget ? Conversion.Identity : 324toConversion = allowAnyTarget ? Conversion.Identity : 350Conversion liftedFromConversion = EncompassingImplicitConversion(sourceExpression, source, nullableFrom, ref useSiteInfo); 351Conversion liftedToConversion = !allowAnyTarget ? 353Conversion.Identity; 594private Conversion EncompassingImplicitConversion(BoundExpression aExpr, TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 605var result = ClassifyStandardImplicitConversion(aExpr, a, b, ref useSiteInfo); 606return IsEncompassingImplicitConversionKind(result.Kind) ? result : Conversion.NoConversion; 609private Conversion EncompassingImplicitConversion(TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

17public readonly Conversion LeftConversion; 18public readonly Conversion RightConversion; 22private BinaryOperatorAnalysisResult(OperatorAnalysisResultKind kind, BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion) 55public static BinaryOperatorAnalysisResult Applicable(BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion) 60public static BinaryOperatorAnalysisResult Inapplicable(BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion)

314Conversion leftConversion = Conversions.FastClassifyConversion(leftType, signature.LeftType); 315Conversion rightConversion = Conversions.FastClassifyConversion(rightType, signature.RightType);

741var convLeft = getOperandConversionForAllowByRefLikeNullCheck(isChecked, left, op.LeftType, ref useSiteInfo); 742var convRight = getOperandConversionForAllowByRefLikeNullCheck(isChecked, right, op.RightType, ref useSiteInfo); 790Conversion getOperandConversionForAllowByRefLikeNullCheck(bool isChecked, BoundExpression operand, TypeSymbol objectType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 792return (operand.Type is TypeParameterSymbol { AllowsRefLikeType: true }) ? Conversion.Boxing : Conversions.ClassifyConversionFromExpression(operand, objectType, isChecked: isChecked, ref useSiteInfo); 813var convLeft = Conversions.ClassifyConversionFromExpression(left, op.LeftType, isChecked: isChecked, ref useSiteInfo); 814var convRight = Conversions.ClassifyConversionFromExpression(right, op.RightType, isChecked: isChecked, ref useSiteInfo);

16public readonly Conversion Conversion; 19private UnaryOperatorAnalysisResult(OperatorAnalysisResultKind kind, UnaryOperatorSignature signature, Conversion conversion) 39public static UnaryOperatorAnalysisResult Applicable(UnaryOperatorSignature signature, Conversion conversion) 44public static UnaryOperatorAnalysisResult Inapplicable(UnaryOperatorSignature signature, Conversion conversion)

114Conversion? conversion = Conversions.FastClassifyConversion(operandType, signature.OperandType);

534var conversion = Conversions.ClassifyConversionFromExpression(operand, op.OperandType, isChecked: isChecked, ref useSiteInfo);

26private readonly ImmutableArray<Conversion> _conversionsOpt; 27public ImmutableArray<Conversion> ConversionsOpt 123ImmutableArray<Conversion> conversionsOpt = default, 154public Conversion ConversionForArg(int arg) 158return Conversion.Identity; 323public static MemberAnalysisResult BadArgumentConversions(ImmutableArray<int> argsToParamsOpt, BitVector badArguments, ImmutableArray<Conversion> conversions, TypeWithAnnotations definitionParamsElementTypeOpt, TypeWithAnnotations paramsElementTypeOpt) 378public static MemberAnalysisResult NormalForm(ImmutableArray<int> argsToParamsOpt, ImmutableArray<Conversion> conversions, bool hasAnyRefOmittedArgument) 383public static MemberAnalysisResult ExpandedForm(ImmutableArray<int> argsToParamsOpt, ImmutableArray<Conversion> conversions, bool hasAnyRefOmittedArgument, TypeWithAnnotations definitionParamsElementType, TypeWithAnnotations paramsElementType) 461static ImmutableArray<Conversion> adjustConversions(ImmutableArray<Conversion> conversions)

2633var c1 = m1.Result.ConversionForArg(i); 2634var c2 = m2.Result.ConversionForArg(i); 2886Conversion conv1, 2889Conversion conv2, 2939private BetterResult BetterConversionFromExpression(BoundExpression node, TypeSymbol t1, Conversion conv1, TypeSymbol t2, Conversion conv2, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool okToDowngradeToNeither) 3048TypeSymbol t1, Conversion conv1, 3049TypeSymbol t2, Conversion conv2, 3082TypeSymbol t1, CollectionExpressionTypeKind kind1, TypeSymbol elementType1, ImmutableArray<Conversion> underlyingElementConversions1, 3083TypeSymbol t2, CollectionExpressionTypeKind kind2, TypeSymbol elementType2, ImmutableArray<Conversion> underlyingElementConversions2, 3134var conversionToE1 = underlyingElementConversions1[i]; 3135var conversionToE2 = underlyingElementConversions2[i]; 3462return BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out okToDowngradeToNeither, betterConversionTargetRecursionLimit - 1); 3468Conversion conv1, 3470Conversion conv2, 3480Conversion conv1, 3482Conversion conv2, 3672private bool IsMethodGroupConversionIncompatibleWithDelegate(BoundMethodGroup node, NamedTypeSymbol delegateType, Conversion conv) 3765currentResult == BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out _, BetterConversionTargetRecursionLimit)); 4546ArrayBuilder<Conversion> conversions = null; 4551Conversion conversion; 4558conversion = Conversion.Identity; 4568conversion = Conversion.NoConversion; 4659conversions = ArrayBuilder<Conversion>.GetInstance(paramCount); 4660conversions.AddMany(Conversion.Identity, argumentPosition); 4671var conversionsArray = conversions != null ? conversions.ToImmutableAndFree() : default(ImmutableArray<Conversion>); 4693private Conversion CheckArgumentForApplicability( 4715return Conversion.NoConversion; 4727return Conversion.ImplicitDynamic; 4738return Conversion.Identity; 4743var conversion = forExtensionMethodThisArg ? 4747Conversion.ImplicitDynamic); 4754return Conversion.NoConversion; 4762return Conversion.Identity; 4766return Conversion.NoConversion;

257Conversion conversion = Conversions.ClassifyConversionFromExpression(caseExpression, SwitchGoverningType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 427Conversion conversion = binder.Conversions.ClassifyImplicitUserDefinedConversionForV6SwitchGoverningType(switchGoverningType, out resultantGoverningType, ref useSiteInfo);

250public static Conversion GetConversion(this BoundExpression boundNode) 259return Conversion.Identity;

443public static Conversion GetConversion(BoundExpression? conversion, BoundValuePlaceholder? placeholder) 448return Conversion.NoConversion; 477return Conversion.Identity;

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

19internal ConversionGroup(Conversion conversion, TypeWithAnnotations explicitType = default) 34internal readonly Conversion Conversion;

933var leftConversion = Conversions.ClassifyConversionFromType(leftType, rightType, isChecked: false, ref useSiteInfo); 939var rightConversion = Conversions.ClassifyConversionFromType(rightType, leftType, isChecked: false, ref useSiteInfo);

2371/// <returns>A <see cref="Conversion"/> that classifies the conversion from the 2373public Conversion ClassifyConversion(ITypeSymbol source, ITypeSymbol destination) 2419return Conversion.NoConversion; 2430return Conversion.NullLiteral; 2433return Conversion.NoConversion; 2436Conversion result = ClassifyConversion(sourceType, destination);

969return new CSharpTypeInfo(declarationTypeSymbol, declarationTypeSymbol, nullabilityInfo, nullabilityInfo, Conversion.Identity); 973return new CSharpTypeInfo(declarationInfo.Type, declarationInfo.Type, declarationInfo.Nullability, declarationInfo.Nullability, Conversion.Identity); 1011public Conversion GetConversion(SyntaxNode expression, CancellationToken cancellationToken = default(CancellationToken)) 1072public Conversion GetSpeculativeConversion(int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption) 2032return new CSharpTypeInfo(member.Type, member.Type, nullability: default, convertedNullability: default, Conversion.Identity); 2086Conversion conversion; 2135conversion = convertedSwitchConversion.IsValid ? convertedSwitchConversion : Conversion.NoConversion; 2142conversion = Conversion.Identity; 2153conversion = Conversion.MakeConditionalExpression(ImmutableArray<Conversion>.Empty); 2160conversion = Conversion.Identity; 2183conversion = Conversion.Identity; 2191conversion = Conversion.Identity; 2236conversion = Conversion.Identity; 2255conversion = Conversion.Identity; 2353return new CSharpTypeInfo(type, type, default, default, Conversion.Identity); 2806public abstract Conversion ClassifyConversion(ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false); 2824public Conversion ClassifyConversion(int position, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 2836return Conversion.NoConversion; 2862return Conversion.NoConversion; 2877internal abstract Conversion ClassifyConversionForCast(ExpressionSyntax expression, TypeSymbol destination); 2893internal Conversion ClassifyConversionForCast(int position, ExpressionSyntax expression, TypeSymbol destination) 2914return Conversion.NoConversion;

29private readonly Conversion _conversion; 47public Conversion? Conversion 53: (Conversion?)_conversion; 77internal DeconstructionInfo(Conversion conversion)

65public Conversion ElementConversion { get; } 70public Conversion CurrentConversion { get; } 83Conversion elementConversion, 84Conversion currentConversion)

430public override Conversion ClassifyConversion( 445return Conversion.NoConversion; 479return Conversion.NoConversion; 487internal override Conversion ClassifyConversionForCast( 503return Conversion.NoConversion;

220public override Conversion ClassifyConversion( 228internal override Conversion ClassifyConversionForCast(

520public override Conversion ClassifyConversion(ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 527return Conversion.NoConversion; 552return Conversion.NoConversion; 558internal override Conversion ClassifyConversionForCast(ExpressionSyntax expression, TypeSymbol destination) 573return Conversion.NoConversion;

15internal static readonly CSharpTypeInfo None = new CSharpTypeInfo(type: null, convertedType: null, nullability: default, convertedNullability: default, Conversion.Identity); 39public readonly Conversion ImplicitConversion; 41internal CSharpTypeInfo(TypeSymbol type, TypeSymbol convertedType, NullabilityInfo nullability, NullabilityInfo convertedNullability, Conversion implicitConversion)

125Conversion c = F.ClassifyEmitConversion(boundLocal, manager.System_Object); 277Conversion.ImplicitReference);

128Conversion.ExplicitReference, 158Conversion.ExplicitReference, 405conversion: Conversion.ExplicitReference, 470conversion: Conversion.ExplicitReference,

102Conversion.ImplicitNumeric), 191Conversion.ImplicitNumeric),

438public static Conversion ClassifyConversion(this Compilation? compilation, ITypeSymbol source, ITypeSymbol destination) 447return Conversion.NoConversion; 764public static Conversion GetConversion(this SemanticModel? semanticModel, SyntaxNode expression, CancellationToken cancellationToken = default(CancellationToken)) 773return Conversion.NoConversion; 778/// Gets the underlying <see cref="Conversion"/> information from this <see cref="IConversionOperation"/>. This 782/// <returns>The underlying <see cref="Conversion"/>.</returns> 784public static Conversion GetConversion(this IConversionOperation conversionExpression) 793return (Conversion)((ConversionOperation)conversionExpression).ConversionConvertible; 804/// Gets the underlying <see cref="Conversion"/> information from this <see cref="ICompoundAssignmentOperation"/>. This 810public static Conversion GetInConversion(this ICompoundAssignmentOperation compoundAssignment) 819return (Conversion)((CompoundAssignmentOperation)compoundAssignment).InConversionConvertible; 830/// Gets the underlying <see cref="Conversion"/> information from this <see cref="ICompoundAssignmentOperation"/>. This 836public static Conversion GetOutConversion(this ICompoundAssignmentOperation compoundAssignment) 845return (Conversion)((CompoundAssignmentOperation)compoundAssignment).OutConversionConvertible; 856/// Gets the underlying element <see cref="Conversion"/> information from this <see cref="ISpreadOperation"/>. 861public static Conversion GetElementConversion(this ISpreadOperation spread) 870return (Conversion)((SpreadOperation)spread).ElementConversionConvertible; 878public static Conversion GetSpeculativeConversion(this SemanticModel? semanticModel, int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption) 887return Conversion.NoConversion; 1330public static Conversion ClassifyConversion(this SemanticModel? semanticModel, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 1341return Conversion.NoConversion; 1350public static Conversion ClassifyConversion(this SemanticModel? semanticModel, int position, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 1359return Conversion.NoConversion;

3008BoundConversion { Conversion: Conversion conversion, Operand: BoundConditionalAccess ca } when CanPropagateStateWhenNotNull(conversion) => ca, 3030protected static bool CanPropagateStateWhenNotNull(Conversion conversion)

272/// The delegate is invoked by <see cref="VisitConversion(BoundConversion, BoundExpression, Conversion, TypeWithAnnotations, TypeWithState, bool, bool, bool, AssignmentKind, ParameterSymbol, bool, bool, bool, bool, Optional&lt;LocalState&gt;,bool, Location, ArrayBuilder&lt;VisitResult&gt;)"/>. 2862var conversion = conversionsWithoutNullability.ClassifyImplicitConversionFromType(actualType, targetType, ref discardedUseSiteInfo); 3939Conversion.Identity, // as only a nullable reinference is being done we expect an identity conversion 4867var conversions = ArrayBuilder<Conversion>.GetInstance(n); 4873(BoundExpression expressionNoConversion, Conversion conversion) = RemoveConversion(expression, includeExplicitConversions: false); 4916_ = VisitConversion(conversionOpt: null, conversionOperand: expressionsNoConversions[i], Conversion.Identity, targetTypeWithNullability: inferredType, operandType: expressionTypes[i], 5018Conversion conversion = conversionsWithoutNullability.ClassifyConversionFromExpression(placeholder, bestType, isChecked: returns[i].isChecked, ref discardedUseSiteInfo); 5213leftConversion = Conversion.Identity; 5233leftConversion = Conversion.Identity; 5335Conversion leftConversion, 5338Conversion rightConversion, 5353Conversion leftConversion, 5357Conversion rightConversion, 5390Conversion conversion, 5491var conversion = _conversions.ClassifyBuiltInConversion(derivedType, baseType, isChecked: false, ref discardedUseSiteInfo); 5501BoundExpression expr, BoundExpression operand, Conversion conversion, ParameterSymbol parameter, TypeWithState operandType, bool isLifted, 5525private void VisitBinaryOperatorOperandConversionAndPostConditions(BoundExpression expr, BoundExpression operand, Conversion conversion, ParameterSymbol parameter, TypeWithState operandType, bool isLifted) 5540Conversion leftConversion, 5984var conversion = GenerateConversionForConditionalOperator(node.LeftOperand, leftType, rightType, reportMismatch: true, isChecked: node.Checked); 6258(var consequence, var consequenceConversion, consequenceRValue) = visitConditionalOperand(consequenceState, originalConsequence); 6263(var alternative, var alternativeConversion, alternativeRValue) = visitConditionalOperand(alternativeState, originalAlternative); 6338TypeWithState consequenceRValue, TypeWithState alternativeRValue, BoundExpression consequence, Conversion consequenceConversion, bool consequenceEndReachable, 6339BoundExpression alternative, Conversion alternativeConversion, bool alternativeEndReachable, TypeWithAnnotations resultTypeWithAnnotations, bool wasTargetTyped) 6389Conversion consequenceConversion, 6392Conversion alternativeConversion, 6405(BoundExpression, Conversion, TypeWithState) visitConditionalOperand(LocalState state, BoundExpression operand) 6407Conversion conversion; 6438Conversion conversion, 7310(ImmutableArray<BoundExpression> argumentsNoConversions, ImmutableArray<Conversion> conversions) = RemoveArgumentConversions(arguments, refKindsOpt); 7325ImmutableArray<Conversion> conversions, 7427conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i], 7515ImmutableArray<Conversion> conversions, 7896Conversion conversion, 8285private (ImmutableArray<BoundExpression> arguments, ImmutableArray<Conversion> conversions) RemoveArgumentConversions( 8290var conversions = default(ImmutableArray<Conversion>); 8294var conversionsBuilder = ArrayBuilder<Conversion>.GetInstance(n); 8300var conversion = Conversion.Identity; 8676private static (BoundExpression expression, Conversion conversion) RemoveConversion(BoundExpression expr, bool includeExplicitConversions) 8695return (expr, Conversion.Identity); 8710return (expr, group?.Conversion ?? Conversion.Identity); 8714private Conversion GenerateConversionForConditionalOperator(BoundExpression sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool reportMismatch, bool isChecked) 8716var conversion = GenerateConversion(_conversions, sourceExpression, sourceType, destinationType, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: isChecked); 8725private Conversion GenerateConversion(Conversions conversions, BoundExpression? sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool fromExplicitCast, bool extensionMethodThisArgument, bool isChecked) 8909(BoundExpression operand, Conversion conversion) = RemoveConversion(node, includeExplicitConversions: true); 8964(BoundExpression operand, Conversion conversion) = RemoveConversion(expr, includeExplicitConversions: false); 8975Conversion conversion, TypeWithState operandType, 9007Func<TypeWithAnnotations, TypeWithState> visitConversionAsContinuation(BoundExpression expr, bool useLegacyWarnings, bool trackMembers, AssignmentKind assignmentKind, BoundExpression operand, Conversion conversion, TypeWithState operandType) 9160Conversion conversion, 9188void trackConvertedValue(FieldSymbol targetField, Conversion conversion, FieldSymbol valueField) 9414Conversion conversion, 9446conversion = Conversion.MakeNullableConversion(ConversionKind.ImplicitNullable, Conversion.Identity); 9974Conversion conversion, 10205var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 10489CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, receiverParameter, receiverType); 10801private void VisitDeconstructionArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt = null) 10815private void VisitDeconstructMethodArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt) 10872var argConversion = RemoveConversion(invocation.Arguments[0], includeExplicitConversions: false).conversion; 10883var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 10924var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 11701Conversion conversion, 11968Conversion conversion = BoundNode.GetConversion(node.ElementConversion, node.ElementPlaceholder); 12231Conversion leftConversion = Conversion.Identity; 12269leftConversion = Conversion.Identity; 12299void afterLeftChildOfBoundUserDefinedConditionalLogicalOperatorHasBeenVisited(BoundUserDefinedConditionalLogicalOperator binary, BoundExpression leftOperand, Conversion leftConversion) 12791private void CheckExtensionMethodThisNullability(BoundExpression expr, Conversion conversion, ParameterSymbol parameter, TypeWithState result)

915var conversions = ArrayBuilder<Conversion>.GetInstance(numSwitchArms); 933(BoundExpression expression, Conversion conversion) = RemoveConversion(arm.Value, includeExplicitConversions: false); 990ArrayBuilder<Conversion> conversions, 1035ArrayBuilder<Conversion> conversions,

2970public BoundConversion(SyntaxNode syntax, BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, InConversionGroupFlags inConversionGroupFlags, TypeSymbol type, bool hasErrors = false) 2993public Conversion Conversion { get; } 3004public BoundConversion Update(BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, InConversionGroupFlags inConversionGroupFlags, TypeSymbol type)

619Conversion c = _F.ClassifyEmitConversion(carchTempRef, pendingCaughtExceptionType); 741Conversion c = _F.ClassifyEmitConversion(pendingExceptionRef, rewrittenSourceType);

495Conversion c = F.ClassifyEmitConversion(awaiterTempRef, awaiterFieldType); 537Conversion c = F.ClassifyEmitConversion(awaiterFieldRef, awaiterTemp.Type); 606F.Convert(notifyCompletionTemp.Type, F.Local(awaiterTemp), Conversion.ExplicitReference)),

171var conversion = node.Conversion;

177Conversion c = _bound.ClassifyEmitConversion(result, ExpressionType); 774Conversion c = _bound.ClassifyEmitConversion(receiver, _objectType); 936Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 946Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 963Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 973Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 1110Conversion c = _bound.ClassifyEmitConversion(args, iEnumerableType); 1254Conversion c = _bound.ClassifyEmitConversion(node, _objectType);

487Conversion c = _factory.ClassifyEmitConversion(value, parameter.Type);

211void visitConversion(Conversion conversion) 225foreach (var underlying in conversion.UnderlyingConversions) 793Conversion c = _factory.ClassifyEmitConversion(input, int64Type); 803Conversion c = _factory.ClassifyEmitConversion(input, uint64Type);

210input = _factory.Convert(inputType, input, Conversion.Identity); 217Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo); 385_factory.Convert(operandType, rewrittenExpr, Conversion.PointerToVoid), 386_factory.Convert(operandType, new BoundLiteral(syntax, ConstantValue.Null, objectType), Conversion.NullToPointer), 432Conversion c = _factory.ClassifyEmitConversion(input, comparisonType); 497_factory.Compilation.Conversions.ClassifyBuiltInConversion(test.Input.Type, typeEvaluation2.Type, isChecked: false, ref useSiteInfo) is Conversion conv &&

49var conversion = BoundNode.GetConversion(operandConversion, operandPlaceholder);

746var conversion = _compilation.Conversions.ClassifyConversionFromExpression(loweredLeft, boolean, isChecked: false, ref useSiteInfo); 2052MakeConversionNode(syntax, call, Conversion.ExplicitReference, type, @checked: false) : 2123rewrittenExpr = MakeConversionNode(syntax, rewrittenExpr, Conversion.Boxing, objectType, @checked: false); 2389: _factory.Convert(_factory.SpecialType(destinationType), numericOperand, Conversion.IntegerToPointer); 2406numericOperand = _factory.Convert(nativeIntType, numericOperand, Conversion.IntegerToPointer, isChecked); 2418numericOperand = _factory.Convert(longType, numericOperand, Conversion.ExplicitNumeric, isChecked); 2419sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2431sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2443sizeOfExpression = _factory.Convert(ulongType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2462: _factory.Convert(convertedMultiplicationResultType, multiplication, Conversion.IntegerToPointer); // NOTE: for some reason, dev10 doesn't check this conversion. 2492Conversion.PointerToInteger);

29private BoundExpression RewriteCollectionExpressionConversion(Conversion conversion, BoundCollectionExpression node) 181Conversion conversion; 513Conversion c = _factory.ClassifyEmitConversion(arrayOrList, collectionType); 729var spreadElementConversion = expressionStatement.Expression is BoundConversion { Conversion: var actualConversion } ? actualConversion : Conversion.Identity;

901Conversion.Boxing,

264Conversion conversion, 283Conversion.Identity, 300Conversion conversion, 421conversion = Conversion.ExplicitNumeric; 472var outerConversion = Conversion.ImplicitNullableWithIdentityUnderlying; 638Conversion c = _factory.ClassifyEmitConversion(rewrittenOperand, parameterType); 802Conversion conversion = MakeConversion(rewrittenOperand, rewrittenType, @checked: @checked, _compilation, _diagnostics, acceptFailingConversion); 818private static Conversion MakeConversion( 828Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo); 852Conversion conversion, 962Conversion conversion, 1050Conversion conversion, 1106Conversion conversion, 1131rewrittenOperand = BoundConversion.SynthesizedNonUserDefined(syntax, rewrittenOperand, Conversion.ImplicitEnumeration, rewrittenOperandType); 1144var userDefinedConversion = new Conversion(conversionKind, method, false); 1159Conversion conversion, 1221Conversion conversion, 1253Conversion conversion, 1293Conversion conversion, 1355Conversion conversion, 1411Conversion conversion, 1418Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked); 1501Conversion conversion, 1757var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1774private Conversion TryMakeConversion(SyntaxNode syntax, Conversion conversion, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1784Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1787return Conversion.NoConversion; 1790Conversion toConversion = TryMakeConversion(syntax, conversion.UserDefinedToConversion, meth.ReturnType, toType, @checked: @checked); 1793return Conversion.NoConversion; 1805var resultConversion = new Conversion(result, conversion.IsImplicit); 1817return Conversion.NoConversion; 1831return Conversion.NoConversion; 1848return Conversion.NoConversion; 1861return Conversion.NoConversion; 1875private Conversion TryMakeConversion(SyntaxNode syntax, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1878var result = TryMakeConversion(syntax, _compilation.Conversions.ClassifyConversionFromType(fromType, toType, isChecked: @checked, ref useSiteInfo), fromType, toType, @checked: @checked); 1886private Conversion TryMakeUserDefinedConversion(SyntaxNode syntax, MethodSymbol meth, TypeSymbol fromType, TypeSymbol toType, bool @checked, bool isImplicit) 1890Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked); 1893return Conversion.NoConversion; 1896Conversion toConversion = TryMakeConversion(syntax, meth.ReturnType, toType, @checked: @checked); 1899return Conversion.NoConversion;

37private BoundExpression? RewriteDeconstruction(BoundTupleExpression left, Conversion conversion, BoundExpression right, bool isUsed) 57Conversion conversion, 213Conversion conversion, 277private ImmutableArray<BoundExpression> GetRightParts(BoundExpression right, Conversion conversion,

312Conversion c0 = _factory.ClassifyEmitConversion(rewrittenReceiver, parameters0Type); 318Conversion c1 = _factory.ClassifyEmitConversion(rewrittenArgument, parameters1Type);

467Conversion.PinnedObjectToPointer);

357Conversion receiverConversion = enumeratorType.IsStructType() ? 358Conversion.Boxing : 359Conversion.ImplicitReference; 499private BoundExpression ConvertReceiverForInvocation(CSharpSyntaxNode syntax, BoundExpression receiver, MethodSymbol method, Conversion receiverConversion, TypeSymbol convertedReceiverType) 1216private static BoundExpression GetUnconvertedCollectionExpression(BoundForEachStatement node, out Conversion collectionConversion)

93Conversion.Boxing,

190Conversion c = _factory.ClassifyEmitConversion(clone, type); 422Conversion c = _factory.ClassifyEmitConversion(instance, node.Type);

134return _factory.Convert(uintPtrType, _factory.Literal((uint)folded), Conversion.IntegerToPointer); 139BoundExpression convertedCount = _factory.Convert(uintType, countExpression, Conversion.ExplicitNumeric); 140convertedCount = _factory.Convert(uintPtrType, convertedCount, Conversion.IntegerToPointer);

128if (tryGetImplicitConversion(savedInputExpression, objectType) is Conversion c && 155Conversion? tryGetImplicitConversion(BoundExpression expression, TypeSymbol type) 158Conversion c = _localRewriter._compilation.Conversions.ClassifyConversionFromExpression(expression, type, isChecked: false, ref discardedUseSiteInfo);

68var elementConversion = underlyingConversions[i]; 214var conversion = Conversion.MakeNullableConversion(ConversionKind.ImplicitNullable, Conversion.Identity); 477BoundExpression MakeBoundConversion(BoundExpression expr, Conversion conversion, TypeWithAnnotations type, BoundConversion enclosing)

162return MakeConversionNode(newNode.Syntax, newNode, Conversion.ExplicitEnumeration, type, @checked: false);

171Conversion.ImplicitDynamic, 247Conversion.ImplicitDynamic,

569var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo); 658Conversion c = Compilation.Conversions.ClassifyBuiltInConversion(operand.Type, type, isChecked: false, ref discardedUseSiteInfo); 690Conversion c; 693c = Conversion.Boxing; 1268? BoundConversion.SynthesizedNonUserDefined(syntax, nullLiteral, Conversion.NullToPointer, type) 1498/// and then calls <see cref="Convert(TypeSymbol, BoundExpression, Conversion, bool)"/>. 1502public Conversion ClassifyEmitConversion(BoundExpression arg, TypeSymbol destination) 1505Conversion c = Compilation.Conversions.ClassifyConversionFromExpression(arg, destination, isChecked: false, ref useSiteInfo); 1515public BoundExpression Convert(TypeSymbol type, BoundExpression arg, Conversion conversion, bool isChecked = false) 1790rewrittenExpr = Convert(objectType, rewrittenExpr, Conversion.Boxing);

1078Conversion conversion = boundConversion.Conversion; 1143Conversion conversion = BoundNode.GetConversion(boundAsOperator.OperandConversion, boundAsOperator.OperandPlaceholder); 1274var elementConversion = BoundNode.GetConversion(iteratorItem, element.ElementPlaceholder); 1360Conversion inConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.LeftConversion, boundCompoundAssignmentOperator.LeftPlaceholder); 1361Conversion outConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.FinalConversion, boundCompoundAssignmentOperator.FinalPlaceholder); 1584Conversion valueConversion = BoundNode.GetConversion(boundNullCoalescingOperator.LeftConversion, boundNullCoalescingOperator.LeftPlaceholder); 1589valueConversion = Conversion.Identity; 1897inlineArrayConversion: enumeratorInfoOpt.InlineArraySpanType is WellKnownType.Unknown ? null : Conversion.InlineArray,

53var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false);

958Conversion conversion = binder.Conversions.ClassifyImplicitConversionFromExpression(defaultExpression, parameterType, ref useSiteInfo);

1207Conversion conversion = conversions.ConvertExtensionMethodThisArg(parameterType: result.ContainingType.ExtensionParameter.Type, receiverType, ref discardedUseSiteInfo, isMethodGroupConversion: false);

62Conversion c = f.ClassifyEmitConversion(itemFieldReference, method.ReturnType);

489Conversion c = f.ClassifyEmitConversion(fieldReference, interfaceType); 545Conversion c = f.ClassifyEmitConversion(thisRef, returnType); 588Conversion c = f.ClassifyEmitConversion(fieldReference, interfaceType); 630Conversion c = f.ClassifyEmitConversion(fieldReference, objectType); 654Conversion c = f.ClassifyEmitConversion(fieldReference, interfaceType); 738Conversion c = f.ClassifyEmitConversion(fieldReference, interfaceType); 792Conversion c = f.ClassifyEmitConversion(parameterReference, fieldType);

67Conversion c = F.ClassifyEmitConversion(parameterRef, objectType);

124Conversion c = F.ClassifyEmitConversion(other, baseType);

63Conversion c = F.ClassifyEmitConversion(paramAccess, ContainingType);

220Conversion c = F.ClassifyEmitConversion(value, objectType);

364var conversion = conversionOperation.GetConversion();

275var conversion = compilation.ClassifyConversion(type1, type2);

14var conversion = semanticModel.GetConversion(conditional, cancellationToken);

166var conversion = speculationAnalyzer.SpeculativeSemanticModel.GetConversion(speculationAnalyzer.ReplacedExpression, cancellationToken); 292var conversion = compilation.ClassifyConversion(type, convertedType);

108var initializerConversion = semanticModel.GetConversion(initializerValue, cancellationToken); 127var elementConversion = semanticModel.GetForEachStatementInfo(forEachStatement).ElementConversion; 139Conversion conversion,

9public static bool IsIdentityOrImplicitReference(this Conversion conversion) 15public static bool IsImplicitUserDefinedConversion(this Conversion conversion)

233var conversion = conversionOperation.GetConversion(); 297var originalConversion = originalConversionOperation.GetConversion(); 407var originalParentConversion = originalParentConversionOperation.GetConversion(); 694var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 749var innerOriginalConversion = originalConversionOperation.GetConversion(); 760var outerOriginalConversion = outerOriginalConversionOperation.GetConversion(); 787var originalConversion = originalConversionOperation.GetConversion(); 813var rewrittenBitwiseNotConversion = rewrittenBitwiseNotConversionOperation.GetConversion(); 920var originalConversion = conversionOperation.GetConversion(); 1005var outerConversion = rewrittenSemanticModel.GetConversion(rewrittenConditionalOrSwitchExpression, cancellationToken); 1119Conversion conversion, 1178var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 1206var parentConversion = semanticModel.GetConversion(castNode, cancellationToken); 1254var conversion = semanticModel.GetConversion(current, cancellationToken); 1364var oldConversion = oldForEachInfo.ElementConversion; 1365var newConversion = newForEachInfo.ElementConversion; 1622private static (ITypeSymbol? rewrittenConvertedType, Conversion rewrittenConversion) GetRewrittenInfo( 1625Conversion originalConversion, ITypeSymbol originalConvertedType, 1641var rewrittenConversion = rewrittenSemanticModel.GetConversion(rewrittenExpression, cancellationToken);

38Conversion> 409var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalOtherPartOfConditional, originalExpressionType); 410var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newOtherPartOfConditional, newExpressionType); 444var originalConversion = this.OriginalSemanticModel.ClassifyConversion(oldSwitchStatement.Expression, originalCaseType); 445var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newSwitchStatement.Expression, newCaseType); 547var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType); 548var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType); 710var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalIsOrAsExpression.Left, originalConvertedType, isExplicitInSource: true); 711var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newIsOrAsExpression.Left, newConvertedType, isExplicitInSource: true); 815var originalConversion = originalModel.GetConversion(originalExpression); 816var newConversion = newModel.GetConversion(newExpression); 853private bool ConversionsAreCompatible(Conversion originalConversion, Conversion newConversion) 934protected override Conversion ClassifyConversion(SemanticModel model, ExpressionSyntax expression, ITypeSymbol targetType) 937protected override Conversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType)

292var conversion = semanticModel.GetConversion(expression, cancellationToken);

102var conversion = semanticModel.Compilation.ClassifyConversion(rightType, leftType);

197var conversion = _semanticModel.Compilation.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType);

141var conversion = compilation.ClassifyConversion(sourceType, targetType);

399var conv = model.GetConversion(expr);

314Assert.Equal(Conversion.UnsetConversion, deconstructionInfo.Conversion); 1130var tupleConversion = model.GetConversion(tuple);

10798var conversion = model.GetConversion(lambdas[0]);

364Assert.Equal(Conversion.Identity, model.GetConversion(tupleX)); 369Assert.Equal(Conversion.Identity, model.GetConversion(lastX)); 387Assert.Equal(Conversion.ImplicitNumeric, model.GetConversion(lastY)); 729Assert.Equal(Conversion.Identity, model.GetConversion(tuple));

7500var castConversion = model.GetConversion(value); 7504var tupleConversion = model.GetConversion(tuple); 7533var tupleConversion = model.GetConversion(value); 7575var conversion1 = model.GetConversion(tuple1); 7584var conversion2 = model.GetConversion(tuple2); 7593var conversion3 = model.GetConversion(tuple3); 7641var conversion = model.GetConversion(tuple); 8329Assert.Equal(Conversion.Identity, model.GetConversion(l11)); 8354Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8496Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8530Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8603Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8632Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8667Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8696Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8756Assert.Equal(Conversion.Identity, model.GetConversion(l11)); 8781Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8841Assert.Equal(Conversion.Identity, model.GetConversion(lnull)); 8854Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8964Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 17217Assert.Equal(Conversion.Identity, model.GetConversion(n1)); 17224Assert.Equal(Conversion.Identity, model.GetConversion(n2)); 17231Assert.Equal(Conversion.Identity, model.GetConversion(n3)); 17238Assert.Equal(Conversion.Identity, model.GetConversion(n4)); 17299Assert.Equal(Conversion.ImplicitReference, model.GetConversion(n4));

64internal static void AssertMatches(ConversionKind[] expected, Conversion conversion)

2831var argConv = model.GetConversion(arg); 2865var conv = op.GetConversion(); 2881var conv = op.GetConversion();

16076var conversion = model.GetConversion(returnValue); 16082var underlyingConversion = conversion.UnderlyingConversions[0]; 16152var conversion = model.GetConversion(returnValue); 16158var underlyingConversion = conversion.UnderlyingConversions[0]; 16225var conversion = model.GetConversion(collection); 16289var castConversion = model.GetConversion(cast); 16294var conversion = model.GetConversion(value); 16413var castConversion = model.GetConversion(cast); 16418var conversion = model.GetConversion(value); 16497var conversion = model.GetConversion(nestedCollection); 16586var conversion = model.GetConversion(nestedCollection); 16592var underlyingConversion = conversion.UnderlyingConversions[0]; 16940var conversion = model.GetConversion(expr); 29083Conversion conversion = conversionOperation.GetConversion(); 29085AssertEx.SequenceEqual([Conversion.Boxing, Conversion.Boxing], conversion.UnderlyingConversions); 29139var expectedConversion = new Conversion(ConversionKind.CollectionExpression, nestedConversions: ImmutableArray.Create(Conversion.Identity, Conversion.Identity)); 29140Conversion actual = conversionOperation.GetConversion(); 29142AssertEx.SequenceEqual(ImmutableArray.Create(Conversion.Identity, Conversion.Identity), actual.UnderlyingConversions); 29375Assert.Equal(Conversion.Boxing, spread.GetElementConversion()); 29397Assert.Equal(Conversion.ImplicitReference, spread.GetElementConversion()); 30962var conversion1 = model.GetConversion(collections[0]); 30966var conversion2 = model.GetConversion(collections[1]); 31006var conversion1 = model.GetConversion(collections[0]); 31010var conversion2 = model.GetConversion(collections[1]); 31055var conversion1 = model.GetConversion(collections[0]); 31060var conversion2 = model.GetConversion(collections[1]); 31096var conversion1 = model.GetConversion(collections[0]); 31100var conversion2 = model.GetConversion(collections[1]); 31139var conversion1 = model.GetConversion(collections[0]); 31143var conversion2 = model.GetConversion(collections[1]); 31182var conversion = model.GetConversion(collection); 31222var conversion = model.GetConversion(collection); 31254var conversion = model.GetConversion(collection); 31288var conversion1 = model.GetConversion(collections[0]); 31292var conversion2 = model.GetConversion(collections[1]); 31300var conversion3 = model.GetConversion(collections[2]); 31308var conversion4 = model.GetConversion(collections[3]); 31341var conversion1 = model.GetConversion(collections[0]); 31345var conversion2 = model.GetConversion(collections[1]); 31353var conversion3 = model.GetConversion(collections[2]); 31361var conversion4 = model.GetConversion(collections[3]); 31407var conversion1 = model.GetConversion(collections[0]); 31410var conversion2 = model.GetConversion(collections[1]); 31417var conversion3 = model.GetConversion(collections[2]); 31424var conversion4 = model.GetConversion(collections[3]); 31468var conversion1 = model.GetConversion(collections[0]); 31471var conversion2 = model.GetConversion(collections[1]); 31478var conversion3 = model.GetConversion(collections[2]); 31485var conversion4 = model.GetConversion(collections[3]); 31544var conversion1 = model.GetConversion(collection); 31587var conversion1 = model.GetConversion(collections[0]); 31592var conversion2 = model.GetConversion(collections[1]); 31634var conversion = model.GetConversion(collection); 35018var collectionConversion = model.GetConversion(collection); 35024var elementConversion = model.GetConversion(element); 35115var elementConversion1 = model.GetConversion(element1); 35121var elementConversion2 = model.GetConversion(element2); 35157var elementConversion1 = model.GetConversion(element1); 35163var elementConversion2 = model.GetConversion(element2); 35203var elementConversion1 = model.GetConversion(element1); 35209var elementConversion2 = model.GetConversion(element2);

1056var conversion = model.ClassifyConversion(decl, model.Compilation.ObjectType, false);

2892var conversion = model.GetConversion(expr);

100var conv = semanticModel.GetConversion(expression, cancellationToken); 133private static bool IsCoClassImplicitConversion(TypeInfo info, Conversion conversion, INamedTypeSymbol? coclassSymbol)

364var conversion = conversionOperation.GetConversion();

275var conversion = compilation.ClassifyConversion(type1, type2);

14var conversion = semanticModel.GetConversion(conditional, cancellationToken);

166var conversion = speculationAnalyzer.SpeculativeSemanticModel.GetConversion(speculationAnalyzer.ReplacedExpression, cancellationToken); 292var conversion = compilation.ClassifyConversion(type, convertedType);

108var initializerConversion = semanticModel.GetConversion(initializerValue, cancellationToken); 127var elementConversion = semanticModel.GetForEachStatementInfo(forEachStatement).ElementConversion; 139Conversion conversion,

102var conversion = semanticModel.Compilation.ClassifyConversion(rightType, leftType);

197var conversion = _semanticModel.Compilation.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType);

141var conversion = compilation.ClassifyConversion(sourceType, targetType);

49var conversion = semanticModel.Compilation.ClassifyConversion(argType, parameters[0].Type);

48Assert.Equal(Conversion.Identity, compoundAssignment.GetInConversion()); 49Assert.Equal(Conversion.Identity, compoundAssignment.GetOutConversion()); 89var inConversion = compoundAssignment.GetInConversion(); 93var outConversion = compoundAssignment.GetOutConversion();

932Assert.Equal(Conversion.Identity, model.GetConversion(literalExpr)); 939Assert.Equal(Conversion.Identity, model.GetConversion(invocExpr));

70var dynamicToObject = c.Conversions.ClassifyConversionFromType(DynamicTypeSymbol.Instance, c.GetSpecialType(SpecialType.System_Object), ref useSiteDiagnostics); 71var objectToDynamic = c.Conversions.ClassifyConversionFromType(c.GetSpecialType(SpecialType.System_Object), DynamicTypeSymbol.Instance, ref useSiteDiagnostics);

1740private static Conversion GetCollectionConversion(BoundForEachStatement boundNode) 2663var conv = model.GetConversion(loopSyntax.Type); 3878Assert.Equal(Conversion.Identity, info.CurrentConversion); 3879Assert.Equal(Conversion.Identity, info.ElementConversion);

213var conversion = model.GetConversion(initializer1); 218var classifiedConversion = comp.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType!); 295var conversion = model.GetConversion(literal); 303var classifiedConversion = model.ClassifyConversion(literal, typeInfo.ConvertedType); 355var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 363var underlying = conversion.UnderlyingConversions.Single(); 406var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 458var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 508var conversion = model.ClassifyConversion(conv.Expression, typeInfoOuter.Type!); 605var conversion = model.GetConversion(decl); 609var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 845var conversion = model.GetConversion(decl); 851var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 903var conversion = model.GetConversion(initializer); 910var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!);

844var conv = model.GetConversion(expr);

56internal static void AssertMatches(ConversionKind[] expected, Conversion conversion)

813var conversion = compilation.Conversions.ClassifyConversionFromExpression(

960var conversion = model.GetConversion(objectCreationExpression); 1000var conversion = model.GetConversion(objectCreationExpression);

3818var conversion = model.GetConversion(literal); 3841var conversion = model.GetConversion(literal); 3865var conversion = model.GetConversion(literal);

3254"valuePlaceholder" => Conversion.Identity, 3257Conversion.NoConversion

253Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 570Assert.Equal(Conversion.Identity, summary.ImplicitConversion);

376Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 382Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 390Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 396Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 404Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 410Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 452Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 458Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 466Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 472Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 480Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 486Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 2368Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2374Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2380Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2386Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2396Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2402Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2408Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2414Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2424Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2430Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2436Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2442Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2474Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2480Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2486Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2496Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2502Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2508Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2518Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2524Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2530Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2580Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2586Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion); 2592Assert.Equal(Conversion.ImplicitNumeric, sizeInfo.ImplicitConversion); 2608Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2614Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion); 2620Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2658Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2664Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 2670Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2680Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2686Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 2692Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion);

336Assert.Equal(Conversion.Identity, model.GetConversion(default2)); 3529Conversion conversion = model.GetConversion(conversionSyntax); 3602Conversion conversion = model.GetConversion(default4);

9844var conversionInTopLevel = speculativeModelInTopLevel.GetConversion(nodeToSpeculate.DescendantTokens().Single(n => n.ValueText == "x").Parent); 9849var conversionOutsideTopLevel = speculativeModelOutsideTopLevel.GetConversion(nodeToSpeculate.DescendantTokens().Single(n => n.ValueText == "x").Parent);

7267var conv = model.GetConversion(syntax); 7270Assert.Equal(Conversion.Identity, conv); 7334var conv = model.GetConversion(syntax); 7337Assert.Equal(Conversion.Identity, conv); 7372var conv = model.GetConversion(syntax); 7375Assert.Equal(Conversion.Identity, conv); 7414var conv = model.GetConversion(syntax); 7417Assert.Equal(Conversion.Identity, conv); 7545var conv = model.GetConversion(syntax); 7548Assert.Equal(Conversion.Identity, conv); 8349var conv = model.GetConversion(node); 8394var conv = model.GetConversion(value); 8884Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 8919Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 9346Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 10237Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 10313Assert.Equal(Conversion.PointerToVoid, summary0.ImplicitConversion); 10320Assert.Equal(Conversion.PointerToVoid, summary1.ImplicitConversion); 10326Assert.Equal(Conversion.PointerToVoid, summary2.ImplicitConversion); 10639Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10651Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 10701Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10713Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 10761Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10773Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 11313Assert.Equal(Conversion.PointerToVoid, stackAllocSummary.ImplicitConversion); 11325Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 11337Assert.Equal(Conversion.ImplicitNumeric, countSummary.ImplicitConversion);

44var conv1 = Conversion.Identity; 53var conv2 = Conversion.NoConversion;

108var conv = model.GetConversion(expr); 142var conv = model.GetConversion(expr); 604var impconv = model.GetConversion(expr1); 605Assert.Equal(Conversion.Identity, impconv); 606Conversion conv = model.ClassifyConversion(expr1, info.ConvertedType); 634var impconv = model.GetConversion(expr1); 638Conversion conv = model.ClassifyConversion(expr1, info.ConvertedType); 649var conversion = info.Type != null && info.ConvertedType != null ? model.Compilation.ClassifyConversion(info.Type, info.ConvertedType) : Conversion.NoConversion; 656ValidateConversion(Conversion.PointerToVoid, ConversionKind.ImplicitPointerToVoid); 657ValidateConversion(Conversion.NullToPointer, ConversionKind.ImplicitNullToPointer); 658ValidateConversion(Conversion.PointerToPointer, ConversionKind.ExplicitPointerToPointer); 659ValidateConversion(Conversion.IntegerToPointer, ConversionKind.ExplicitIntegerToPointer); 660ValidateConversion(Conversion.PointerToInteger, ConversionKind.ExplicitPointerToInteger); 661ValidateConversion(Conversion.IntPtr, ConversionKind.IntPtr); 665private void ValidateConversion(Conversion conv, ConversionKind kind) 848var conv = semanticModel.GetConversion(expr); 851Conversion act1 = semanticModel.ClassifyConversion(expr, info.ConvertedType); 864var act2 = semanticModel.Compilation.ClassifyConversion(info.Type, info.ConvertedType); 877Conversion act1 = semanticModel.ClassifyConversion(expr, expsym); 2457var conv = model.GetConversion(expr); 2486var conv = model.GetConversion(expr); 2735var conv = model.GetConversion(expr); 2736Assert.Equal(Conversion.Identity, conv); 2806var conv = model.GetConversion(expr); 3337var conversion = model.ClassifyConversion(expr, gNullableType); 3403var conversion = model.ClassifyConversion(expr, gNullableType); 3478var argConversion = model.GetConversion(argexpr); 3532var argConversion = model.GetConversion(argexpr); 3611var conv = model.GetConversion(literal); 3636var literalConversion = model.GetConversion(literal); 3644var castConversion = model.GetConversion(cast); 3669var literalConversion = model.GetConversion(literal); 3677var castConversion = model.GetConversion(cast); 3705var literalConversion = model.GetConversion(literal); 3713var cast1Conversion = model.GetConversion(cast1); 3725var cast2Conversion = model.GetConversion(cast2); 4301Assert.Equal(Conversion.Identity, info.ImplicitConversion); 4380var conv = model.GetConversion(syntax); 5550var conversion = model.ClassifyConversion(lambdaSyntax, otherFuncType); 5598var conversion = model.ClassifyConversion(nullSyntax, typeC); 5637var conversion = model.ClassifyConversion(lambdaSyntax, typeFuncB); 5684var conversion = model.ClassifyConversion(lambdaSyntax, typeFuncC); 5745var conversionA = model.ClassifyConversion(methodGroupSyntax, typeFuncA); 5749var conversionB = model.ClassifyConversion(methodGroupSyntax, typeFuncB); 5752var conversionC = model.ClassifyConversion(methodGroupSyntax, typeFuncC); 6003Assert.Equal(Conversion.UnsetConversion, foreachSymbolInfo.CurrentConversion);

2281var conv = speculativeModel.GetConversion(initializer);

14808var conv = model.GetConversion(creation.Type); 14904var conv = model.GetConversion(creation.Type); 15015var conv = model.GetConversion(creation.Type);

183var result = c.ClassifyConversionFromType(types[j], types[i], ref useSiteDiagnostics); 187var result2 = c.ClassifyConversionFromType(types[j], types[i], ref useSiteDiagnostics); // set breakpoint here if this test is failing... 403Conversion conversion = model.ClassifyConversion(sourceExpression1, targetType); 487var conversion = model.GetConversion(memberAccess); 522var conversion = model.GetConversion(memberAccess); 558var conversion = model.GetConversion(memberAccess); 594var conversion = model.GetConversion(memberAccess); 628var conversion = model.GetConversion(memberAccess); 663var conversion = model.GetConversion(memberAccess); 688var conversion = model.GetConversion(memberAccess); 2080var elementConversion = BoundNode.GetConversion(boundForEach.ElementConversion, boundForEach.ElementPlaceholder);

214public Conversion ImplicitConversion = default(Conversion);

887public static Conversion ClassifyConversionFromType(this ConversionsBase conversions, TypeSymbol source, TypeSymbol destination, ref HashSet<DiagnosticInfo> useSiteDiagnostics, bool forCast = false) 890Conversion result = conversions.ClassifyConversionFromType(source, destination, isChecked: false, ref useSiteInfo, forCast); 910public static Conversion ClassifyConversionFromExpression(this Conversions conversions, BoundExpression sourceExpression, TypeSymbol destination, ref HashSet<DiagnosticInfo> useSiteDiagnostics, bool forCast = false) 913Conversion result = conversions.ClassifyConversionFromExpression(sourceExpression, destination, isChecked: false, ref useSiteInfo, forCast);

9public static bool IsIdentityOrImplicitReference(this Conversion conversion) 15public static bool IsImplicitUserDefinedConversion(this Conversion conversion)

233var conversion = conversionOperation.GetConversion(); 297var originalConversion = originalConversionOperation.GetConversion(); 407var originalParentConversion = originalParentConversionOperation.GetConversion(); 694var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 749var innerOriginalConversion = originalConversionOperation.GetConversion(); 760var outerOriginalConversion = outerOriginalConversionOperation.GetConversion(); 787var originalConversion = originalConversionOperation.GetConversion(); 813var rewrittenBitwiseNotConversion = rewrittenBitwiseNotConversionOperation.GetConversion(); 920var originalConversion = conversionOperation.GetConversion(); 1005var outerConversion = rewrittenSemanticModel.GetConversion(rewrittenConditionalOrSwitchExpression, cancellationToken); 1119Conversion conversion, 1178var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 1206var parentConversion = semanticModel.GetConversion(castNode, cancellationToken); 1254var conversion = semanticModel.GetConversion(current, cancellationToken); 1364var oldConversion = oldForEachInfo.ElementConversion; 1365var newConversion = newForEachInfo.ElementConversion; 1622private static (ITypeSymbol? rewrittenConvertedType, Conversion rewrittenConversion) GetRewrittenInfo( 1625Conversion originalConversion, ITypeSymbol originalConvertedType, 1641var rewrittenConversion = rewrittenSemanticModel.GetConversion(rewrittenExpression, cancellationToken);

38Conversion> 409var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalOtherPartOfConditional, originalExpressionType); 410var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newOtherPartOfConditional, newExpressionType); 444var originalConversion = this.OriginalSemanticModel.ClassifyConversion(oldSwitchStatement.Expression, originalCaseType); 445var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newSwitchStatement.Expression, newCaseType); 547var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType); 548var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType); 710var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalIsOrAsExpression.Left, originalConvertedType, isExplicitInSource: true); 711var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newIsOrAsExpression.Left, newConvertedType, isExplicitInSource: true); 815var originalConversion = originalModel.GetConversion(originalExpression); 816var newConversion = newModel.GetConversion(newExpression); 853private bool ConversionsAreCompatible(Conversion originalConversion, Conversion newConversion) 934protected override Conversion ClassifyConversion(SemanticModel model, ExpressionSyntax expression, ITypeSymbol targetType) 937protected override Conversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType)

292var conversion = semanticModel.GetConversion(expression, cancellationToken);

852CSharp.Conversion csharpConversion = CSharp.CSharpExtensions.GetConversion(operation); 1181var inConversionInternal = CSharp.CSharpExtensions.GetInConversion(operation); 1182var outConversionInternal = CSharp.CSharpExtensions.GetOutConversion(operation);

728Conversion conversion = _compilation.ClassifyConversion(source, dest);

730var conversion = _compilation.ClassifyConversion(source, dest);

54var conversion = comp.ClassifyConversion(source, dest);

59var conversion = comp.ClassifyConversion(source, dest);

287var conversion = _compilation.ClassifyConversion(source, dest);

59var conversion = comp.ClassifyConversion(source, dest);

287var conversion = _compilation.ClassifyConversion(source, dest);

59var conversion = comp.ClassifyConversion(source, dest);

59var conversion = comp.ClassifyConversion(source, dest);

59var conversion = comp.ClassifyConversion(source, dest);

9public static bool IsIdentityOrImplicitReference(this Conversion conversion) 15public static bool IsImplicitUserDefinedConversion(this Conversion conversion)

233var conversion = conversionOperation.GetConversion(); 297var originalConversion = originalConversionOperation.GetConversion(); 407var originalParentConversion = originalParentConversionOperation.GetConversion(); 694var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 749var innerOriginalConversion = originalConversionOperation.GetConversion(); 760var outerOriginalConversion = outerOriginalConversionOperation.GetConversion(); 787var originalConversion = originalConversionOperation.GetConversion(); 813var rewrittenBitwiseNotConversion = rewrittenBitwiseNotConversionOperation.GetConversion(); 920var originalConversion = conversionOperation.GetConversion(); 1005var outerConversion = rewrittenSemanticModel.GetConversion(rewrittenConditionalOrSwitchExpression, cancellationToken); 1119Conversion conversion, 1178var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 1206var parentConversion = semanticModel.GetConversion(castNode, cancellationToken); 1254var conversion = semanticModel.GetConversion(current, cancellationToken); 1364var oldConversion = oldForEachInfo.ElementConversion; 1365var newConversion = newForEachInfo.ElementConversion; 1622private static (ITypeSymbol? rewrittenConvertedType, Conversion rewrittenConversion) GetRewrittenInfo( 1625Conversion originalConversion, ITypeSymbol originalConvertedType, 1641var rewrittenConversion = rewrittenSemanticModel.GetConversion(rewrittenExpression, cancellationToken);

38Conversion> 409var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalOtherPartOfConditional, originalExpressionType); 410var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newOtherPartOfConditional, newExpressionType); 444var originalConversion = this.OriginalSemanticModel.ClassifyConversion(oldSwitchStatement.Expression, originalCaseType); 445var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newSwitchStatement.Expression, newCaseType); 547var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType); 548var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType); 710var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalIsOrAsExpression.Left, originalConvertedType, isExplicitInSource: true); 711var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newIsOrAsExpression.Left, newConvertedType, isExplicitInSource: true); 815var originalConversion = originalModel.GetConversion(originalExpression); 816var newConversion = newModel.GetConversion(newExpression); 853private bool ConversionsAreCompatible(Conversion originalConversion, Conversion newConversion) 934protected override Conversion ClassifyConversion(SemanticModel model, ExpressionSyntax expression, ITypeSymbol targetType) 937protected override Conversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType)

292var conversion = semanticModel.GetConversion(expression, cancellationToken);

1134Conversion conversion = _knownSymbols.Compilation.ClassifyConversion(dictionaryType, type);