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

135return new Conversion( 142return new Conversion( 209return new Conversion(this.Kind, conversionMethod, isExtensionMethod: IsExtensionMethod); 217return new Conversion( 275return new Conversion(kind); 278internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 279internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 280internal static Conversion Identity => new Conversion(ConversionKind.Identity); 281internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 282internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 283internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 284internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 285internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 286internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 287internal static Conversion CollectionExpression => new Conversion(ConversionKind.CollectionExpression); 288internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 289internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 290internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 291internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 292internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 293internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 294internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 295internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 296internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 297internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 298internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 299internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 300internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 301internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 302internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 303internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 304internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 305internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 306internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 307internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 308internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 309internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 310internal static Conversion InlineArray => new Conversion(ConversionKind.InlineArray); 311internal static Conversion ImplicitSpan => new Conversion(ConversionKind.ImplicitSpan); 312internal static Conversion ExplicitSpan => new Conversion(ConversionKind.ExplicitSpan); 324internal static readonly Conversion ExplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitEnumerationUnderlying); 325internal static readonly Conversion ExplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ExplicitNullable, PointerToIntegerUnderlying); 326internal static readonly Conversion ExplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ExplicitNullable, IdentityUnderlying); 327internal static readonly Conversion ExplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitNumericUnderlying); 328internal static readonly Conversion ExplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitNumericUnderlying); 329internal static readonly Conversion ExplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitConstantUnderlying); 331internal static readonly Conversion ImplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitEnumerationUnderlying); 332internal static readonly Conversion ImplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ImplicitNullable, PointerToIntegerUnderlying); 333internal static readonly Conversion ImplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ImplicitNullable, IdentityUnderlying); 334internal static readonly Conversion ImplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitNumericUnderlying); 335internal static readonly Conversion ImplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitNumericUnderlying); 336internal static readonly Conversion ImplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitConstantUnderlying); 352return new Conversion(ConversionKind.StackAllocToPointerType, ImmutableArray.Create(underlyingConversion)); 357return new Conversion(ConversionKind.StackAllocToSpanType, ImmutableArray.Create(underlyingConversion)); 372_ => new Conversion(kind, ImmutableArray.Create(nestedConversion)), 378return new Conversion(ConversionKind.SwitchExpression, innerConversions); 383return new Conversion(ConversionKind.ConditionalExpression, innerConversions);

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

785var result = new Conversion(conversionResult, isImplicit: true); 889return new Conversion(conversionResult, isImplicit: false); 1191return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingConversion)); 1327return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1356return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1763return new Conversion(result, isImplicit: true); 2289return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(tupleConversion)); 2371return new Conversion(kind, argumentConversions.ToImmutableAndFree()); 2450return new Conversion(kind, nestedConversions.ToImmutableAndFree()); 2492return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(tupleConversion));

2112conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, false); 2233conversion = new Conversion(ConversionKind.MethodGroup, delegateCreation.MethodOpt, delegateCreation.IsExtensionMethod); 2239conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, delegateCreation.IsExtensionMethod); 2245conversion = new Conversion(ConversionKind.AnonymousFunction, lambda.Symbol, delegateCreation.IsExtensionMethod);

1197var userDefinedConversion = new Conversion(conversionKind, method, false); 1836var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1884var resultConversion = new Conversion(result, conversion.IsImplicit); 1989return new Conversion(result, isImplicit);

29200var 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);

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

4270if (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) 685var 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, BoundExpression result) 137Conversion conversion, 359void reportUseSiteDiagnostics(SyntaxNode syntax, Conversion conversion, BoundExpression source, TypeSymbol destination, BindingDiagnosticBag diagnostics) 374void ensureAllUnderlyingConversionsChecked(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool wasCompilerGenerated, TypeSymbol destination, BindingDiagnosticBag diagnostics) 471void checkConstraintLanguageVersionAndRuntimeSupportForConversion(SyntaxNode syntax, Conversion conversion, BoundExpression source, TypeSymbol destination, BindingDiagnosticBag diagnostics) 811SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, Conversion conversion, bool isCast, TypeSymbol destination, 833expr is BoundBadExpression ? Conversion.NoConversion : conversion, 880Conversion conversion, 898Conversion conversion, 904private readonly Conversion _conversion = conversion; 1147var elementConversion = elementConversions[i]; 1170ref readonly CollectionExpressionConverter @this, BoundCollectionExpressionSpreadElement element, TypeSymbol elementType, Conversion elementConversion) 1574var conversion = Conversions.ClassifyImplicitConversionFromType(elementTypeOriginalDefinition, elementType, ref candidateUseSiteInfo); 2129var conversion = conversions.ConvertExtensionMethodThisArg(constructed.Parameters[0].Type, receiverType, ref useSiteInfo, isMethodGroupConversion: false); 2391Conversion elementConversion = Conversions.GetCollectionExpressionSpreadElementConversion(spreadElement, elementType, ref useSiteInfo); 2401Conversion elementConversion = Conversions.ClassifyImplicitConversionFromExpression((BoundExpression)element, elementType, ref useSiteInfo); 2426Conversion? conversionIfTargetTyped, 2432var conversion = conversionIfTargetTyped.GetValueOrDefault(); 2433ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions; 2466private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, Conversion? conversionIfTargetTyped, BindingDiagnosticBag diagnostics, bool hasErrors = false) 2469Conversion conversion = conversionIfTargetTyped ?? Conversion.Identity; 2471ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions; 2496Conversion conversion, 2575Conversion toParameterTypeConversion = Conversions.ClassifyStandardConversion(convertedOperand.Type, conversionParameterType, ref useSiteInfo); 2596Conversion toConversion = conversion.UserDefinedToConversion; 2627Conversion fromReturnTypeConversion = Conversions.ClassifyStandardConversion(conversionReturnType, conversionToType, ref useSiteInfo); 2685Conversion conversion, 2760SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2821SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 2852SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 3013SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, 3048var underlyingConversion = conversion.UnderlyingConversions.Single(); 3053SyntaxNode syntax, BoundTupleLiteral sourceTuple, Conversion conversion, bool isCast, 3065var conversionWithoutNullable = conversion; 3120var elementConversion = underlyingConversions[i]; 3158Conversion.Identity, 3180private BoundMethodGroup FixMethodGroupWithTypeOrValue(BoundMethodGroup group, Conversion conversion, BindingDiagnosticBag diagnostics) 3631Conversion conversion, 3699out Conversion conversion) 3703conversion = Conversion.NoConversion; 3731Conversion 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); 2705Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, intType, ref useSiteInfo); 2811Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, indexType, ref useSiteInfo); 2826Conversion conversion = this.Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 2843Conversion conversion, 2984var elementConversion = Conversions.ClassifyConversionFromExpression(argument, targetElementType, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3010var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3569var kind = result.ConversionForArg(arg); 3751var interpolatedStringConversion = result.ConversionForArg(interpolatedStringArgNum); 5413var conversion = @this.Conversions.ClassifyConversionFromExpression(expression, collectionType, isChecked: @this.CheckOverflowAtRuntime, ref useSiteInfo); 5564var conversion = this.Conversions.ClassifyConversionFromExpression(unboundLambda, type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5604Conversion conversion; 5637Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 7176Conversion conversion = this.Conversions.ClassifyConversionFromExpression(classCreation, interfaceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 9242Conversion.ImplicitNumeric, 10098Conversion failedConversion = this.Conversions.ClassifyConversionFromExpression(index, int32, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 10153Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(expr, targetType, ref useSiteInfo);

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

76var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 294Conversion rightToLeftConversion = this.Conversions.ClassifyConversionFromExpression(right, leftType, isChecked: checkOverflowAtRuntime, ref useSiteInfo); 498Conversion conversion = overloadResolutionResult.ValidResult.Result.ConversionForArg(0); 702Conversion argumentConversion = this.Conversions.ClassifyConversionFromExpression(right, delegateType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1313var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 1605var implicitConversion = Conversions.ClassifyImplicitConversionFromExpression(left, booleanType, ref useSiteInfo); 3581Conversion conversion = overloadResolutionResult.ValidResult.Result.ConversionForArg(0); 4959Conversion conv = Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 4980Conversion conversion = Conversions.ClassifyBuiltInConversion(inputType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5438Conversion.NullLiteral, 5477Conversion conversion = Conversions.ClassifyBuiltInConversion(operandType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 5720var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType0, ref useSiteInfo); 5738var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType, ref useSiteInfo); 5775Conversion leftConversionClassification; 5853var underlyingRightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, underlyingLeftType, ref useSiteInfo); 5867var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, leftType, ref useSiteInfo);

653var convertedExpression = BindExpressionOrTypeForPattern(unionType, inputType, innerExpression, ref hasErrors, diagnostics, out var constantValueOpt, out bool wasExpression, out Conversion patternConversion, out BoundExpression originalExpression); 704private bool ShouldBlockINumberBaseConversion(Conversion patternConversion, TypeSymbol inputType) 756out Conversion patternExpressionConversion, 770patternExpressionConversion = Conversion.NoConversion; 786out Conversion patternExpressionConversion, 793patternExpressionConversion = Conversion.NoConversion; 805out Conversion patternExpressionConversion) 851out Conversion patternExpressionConversion) 898patternExpressionConversion = Conversion.NoConversion; 905patternExpressionConversion = Conversion.NoConversion; 934patternExpressionConversion = Conversion.NoConversion; 1070Conversion conversion; 1098bool reportBadMatch(SyntaxNode typeSyntax, TypeSymbol inputType, TypeSymbol patternType, ConstantValue matchPossible, Conversion conversion, BindingDiagnosticBag diagnostics) 1131out Conversion conversion, 1136conversion = Conversion.NoConversion; 1166out Conversion conversion, 1176conversion = Conversion.Identity; 2066BoundExpression value = BindExpressionForPattern(unionType, inputType, node.Expression, ref hasErrors, diagnostics, out var constantValueOpt, out _, out Conversion patternConversion, originalExpression: out _);

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; 3194conversion = Conversion.NoConversion;

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

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

484Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 538Conversion collectionConversionClassification = this.Conversions.ClassifyConversionFromExpression(collectionExpr, builder.CollectionType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 539Conversion currentConversionClassification = this.Conversions.ClassifyConversionFromType(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 642Conversion collectionConversionClassification, 1557var 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);

20public readonly struct Conversion : IEquatable<Conversion>, IConvertibleConversion 84public NestedUncommonData(ImmutableArray<Conversion> nestedConversions) 89internal readonly ImmutableArray<Conversion> _nestedConversionsOpt; 113ImmutableArray<Conversion> elementConversions) : 130internal static Conversion CreateCollectionExpressionConversion( 133ImmutableArray<Conversion> elementConversions) 140internal static Conversion CreateUnionConversion(UserDefinedConversionResult conversionResult) 185internal Conversion(ConversionKind kind, ImmutableArray<Conversion> nestedConversions) 200internal Conversion SetConversionMethod(MethodSymbol conversionMethod) 212internal Conversion SetArrayIndexConversionForDynamic() 272internal static Conversion GetTrivialConversion(ConversionKind kind) 278internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 279internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 280internal static Conversion Identity => new Conversion(ConversionKind.Identity); 281internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 282internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 283internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 284internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 285internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 286internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 287internal static Conversion CollectionExpression => new Conversion(ConversionKind.CollectionExpression); 288internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 289internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 290internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 291internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 292internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 293internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 294internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 295internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 296internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 297internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 298internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 299internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 300internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 301internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 302internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 303internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 304internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 305internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 306internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 307internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 308internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 309internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 310internal static Conversion InlineArray => new Conversion(ConversionKind.InlineArray); 311internal static Conversion ImplicitSpan => new Conversion(ConversionKind.ImplicitSpan); 312internal static Conversion ExplicitSpan => new Conversion(ConversionKind.ExplicitSpan); 316internal static ImmutableArray<Conversion> IdentityUnderlying => ConversionSingletons.IdentityUnderlying; 317internal static ImmutableArray<Conversion> ImplicitConstantUnderlying => ConversionSingletons.ImplicitConstantUnderlying; 318internal static ImmutableArray<Conversion> ImplicitNumericUnderlying => ConversionSingletons.ImplicitNumericUnderlying; 319internal static ImmutableArray<Conversion> ExplicitNumericUnderlying => ConversionSingletons.ExplicitNumericUnderlying; 320internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying => ConversionSingletons.ExplicitEnumerationUnderlying; 321internal static ImmutableArray<Conversion> PointerToIntegerUnderlying => ConversionSingletons.PointerToIntegerUnderlying; 324internal static readonly Conversion ExplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitEnumerationUnderlying); 325internal static readonly Conversion ExplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ExplicitNullable, PointerToIntegerUnderlying); 326internal static readonly Conversion ExplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ExplicitNullable, IdentityUnderlying); 327internal static readonly Conversion ExplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitNumericUnderlying); 328internal static readonly Conversion ExplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ExplicitNullable, ExplicitNumericUnderlying); 329internal static readonly Conversion ExplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ExplicitNullable, ImplicitConstantUnderlying); 331internal static readonly Conversion ImplicitNullableWithExplicitEnumerationUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitEnumerationUnderlying); 332internal static readonly Conversion ImplicitNullableWithPointerToIntegerUnderlying = new Conversion(ConversionKind.ImplicitNullable, PointerToIntegerUnderlying); 333internal static readonly Conversion ImplicitNullableWithIdentityUnderlying = new Conversion(ConversionKind.ImplicitNullable, IdentityUnderlying); 334internal static readonly Conversion ImplicitNullableWithImplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitNumericUnderlying); 335internal static readonly Conversion ImplicitNullableWithExplicitNumericUnderlying = new Conversion(ConversionKind.ImplicitNullable, ExplicitNumericUnderlying); 336internal static readonly Conversion ImplicitNullableWithImplicitConstantUnderlying = new Conversion(ConversionKind.ImplicitNullable, ImplicitConstantUnderlying); 342internal static ImmutableArray<Conversion> IdentityUnderlying = ImmutableArray.Create(Identity); 343internal static ImmutableArray<Conversion> ImplicitConstantUnderlying = ImmutableArray.Create(ImplicitConstant); 344internal static ImmutableArray<Conversion> ImplicitNumericUnderlying = ImmutableArray.Create(ImplicitNumeric); 345internal static ImmutableArray<Conversion> ExplicitNumericUnderlying = ImmutableArray.Create(ExplicitNumeric); 346internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying = ImmutableArray.Create(ExplicitEnumeration); 347internal static ImmutableArray<Conversion> PointerToIntegerUnderlying = ImmutableArray.Create(PointerToInteger); 350internal static Conversion MakeStackAllocToPointerType(Conversion underlyingConversion) 355internal static Conversion MakeStackAllocToSpanType(Conversion underlyingConversion) 360internal static Conversion MakeNullableConversion(ConversionKind kind, Conversion nestedConversion) 376internal static Conversion MakeSwitchExpression(ImmutableArray<Conversion> innerConversions) 381internal static Conversion MakeConditionalExpression(ImmutableArray<Conversion> innerConversions) 410internal ImmutableArray<Conversion> UnderlyingConversions 416default(ImmutableArray<Conversion>); 437foreach (var underlying in underlyingConversions) 483foreach (var underlying in underlyingConversions) 601foreach (var conv in nestedConversions) 1120internal Conversion UserDefinedFromConversion 1125return best == null ? Conversion.NoConversion : best.SourceConversion; 1132internal Conversion UserDefinedToConversion 1137return best == null ? Conversion.NoConversion : best.TargetConversion; 1202/// This is a lossy conversion; it is not possible to recover the original <see cref="Conversion"/> 1222/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1224/// <param name="obj">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1225/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1228return obj is Conversion && this.Equals((Conversion)obj); 1232/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1234/// <param name="other">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1235/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1236public bool Equals(Conversion other) 1242/// Returns a hash code for the current <see cref="Conversion"/> object. 1244/// <returns>A hash code for the current <see cref="Conversion"/> object.</returns> 1251/// Returns true if the specified <see cref="Conversion"/> objects are equal and false otherwise. 1253/// <param name="left">The first <see cref="Conversion"/> object.</param> 1254/// <param name="right">The second <see cref="Conversion"/> object.</param> 1256public static bool operator ==(Conversion left, Conversion right) 1262/// Returns false if the specified <see cref="Conversion"/> objects are equal and true otherwise. 1264/// <param name="left">The first <see cref="Conversion"/> object.</param> 1265/// <param name="right">The second <see cref="Conversion"/> object.</param> 1267public static bool operator !=(Conversion left, Conversion right) 1277TreeDumperNode 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; 196return Conversion.NoConversion; 202return Conversion.NoConversion; 206var builder = ArrayBuilder<Conversion>.GetInstance(elements.Length); 209Conversion elementConversion = convertElement(element, elementType, ref useSiteInfo); 213return Conversion.NoConversion; 219return Conversion.CreateCollectionExpressionConversion(collectionTypeKind, elementType, constructor, isExpanded, builder.ToImmutableAndFree()); 221Conversion convertElement(BoundNode element, TypeSymbol elementType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 231internal Conversion GetCollectionExpressionSpreadElementConversion( 239return Conversion.NoConversion; 247protected override Conversion AnalyzeImplicitUnionConversions(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol target, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 253return Conversion.NoConversion; 408public Conversion MethodGroupConversion(SyntaxNode syntax, MethodGroup methodGroup, NamedTypeSymbol delegateType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 427var conversion = ToConversion(result, methodGroup, delegateType.DelegateInvokeMethod.ParameterCount); 459private static Conversion ToConversion(OverloadResolutionResult<MethodSymbol> result, MethodGroup methodGroup, int parameterCount) 479return Conversion.NoConversion; 488return Conversion.NoConversion; 495return Conversion.NoConversion; 500return Conversion.NoConversion; 520public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 528var pointerConversion = ClassifyImplicitConversionFromType(sourceAsPointer, destination, ref useSiteInfo); 532return Conversion.MakeStackAllocToPointerType(pointerConversion); 540var spanConversion = ClassifyImplicitConversionFromType(spanType_T, destination, ref useSiteInfo); 544return Conversion.MakeStackAllocToSpanType(spanConversion); 550return 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 = GetImplicitUserDefinedOrUnionConversion(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 GetImplicitUserDefinedOrUnionConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 785var result = new Conversion(conversionResult, isImplicit: true); 792Conversion unionConversion = AnalyzeImplicitUnionConversions(sourceExpression, source, destination, ref useSiteInfo); 802private Conversion GetImplicitUserDefinedOrUnionConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 807private Conversion ClassifyExplicitBuiltInOnlyConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 814return Conversion.NoConversion; 828return Conversion.IntPtr; 833return Conversion.ExplicitEnumeration; 836var nullableConversion = ClassifyExplicitNullableConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 844return (source.Kind == SymbolKind.DynamicType) ? Conversion.ExplicitDynamic : Conversion.ExplicitReference; 849return Conversion.Unboxing; 852var tupleConversion = ClassifyExplicitTupleConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 860return Conversion.PointerToPointer; 865return Conversion.PointerToInteger; 870return Conversion.IntegerToPointer; 875return Conversion.ExplicitDynamic; 880return Conversion.ExplicitSpan; 883return Conversion.NoConversion; 886private Conversion GetExplicitUserDefinedConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 892private Conversion GetExplicitUserDefinedConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 897private Conversion DeriveStandardExplicitFromOppositeStandardImplicitConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 899var oppositeConversion = ClassifyStandardImplicitConversion(destination, source, ref useSiteInfo); 900Conversion impliedExplicitConversion; 905impliedExplicitConversion = Conversion.Identity; 908impliedExplicitConversion = Conversion.ExplicitNumeric; 911impliedExplicitConversion = Conversion.ExplicitReference; 914impliedExplicitConversion = Conversion.Unboxing; 917impliedExplicitConversion = Conversion.NoConversion; 920impliedExplicitConversion = Conversion.PointerToPointer; 926impliedExplicitConversion = Conversion.NoConversion; 932var underlyingConversion = DeriveStandardExplicitFromOppositeStandardImplicitConversion(strippedSource, strippedDestination, ref useSiteInfo); 937Conversion.MakeNullableConversion(ConversionKind.ExplicitNullable, underlyingConversion) : 938Conversion.NoConversion; 943impliedExplicitConversion = Conversion.NoConversion; 1024private static bool ExplicitConversionMayDifferFromImplicit(Conversion implicitConversion) 1044private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1053return Conversion.ImplicitDynamic; 1060return Conversion.NoConversion; 1065return Conversion.ImplicitEnumeration; 1068var constantConversion = ClassifyImplicitConstantExpressionConversion(sourceExpression, destination); 1077var nullLiteralConversion = ClassifyNullLiteralConversion(sourceExpression, destination); 1085return Conversion.DefaultLiteral; 1090var innerConversion = ClassifyImplicitBuiltInConversionFromExpression(innerExpression, innerExpression.Type, destination, ref useSiteInfo); 1098var tupleConversion = ClassifyImplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, ref useSiteInfo); 1108return Conversion.AnonymousFunction; 1113Conversion methodGroupConversion = GetMethodGroupDelegateConversion((BoundMethodGroup)sourceExpression, destination, ref useSiteInfo); 1122Conversion interpolatedStringConversion = GetInterpolatedStringConversion(sourceExpression, destination, ref useSiteInfo); 1129var stackAllocConversion = GetStackAllocConversion((BoundStackAllocArrayCreation)sourceExpression, destination, ref useSiteInfo); 1137var addressOfConversion = GetMethodGroupFunctionPointerConversion(((BoundUnconvertedAddressOfOperator)sourceExpression).Operand, funcPtrType, ref useSiteInfo); 1145return Conversion.ImplicitThrow; 1148return Conversion.ObjectCreation; 1151var collectionExpressionConversion = GetImplicitCollectionExpressionConversion((BoundUnconvertedCollectionExpression)sourceExpression, destination, ref useSiteInfo); 1167return Conversion.InlineArray; 1170return Conversion.NoConversion; 1174private Conversion GetImplicitCollectionExpressionConversion(BoundUnconvertedCollectionExpression collectionExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1176var collectionExpressionConversion = GetCollectionExpressionConversion(collectionExpression, destination, ref useSiteInfo); 1188var underlyingConversion = GetCollectionExpressionConversion(collectionExpression, underlyingDestination, ref useSiteInfo); 1195return Conversion.NoConversion; 1199private Conversion GetSwitchExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1207return Conversion.NoConversion; 1209var innerConversions = ArrayBuilder<Conversion>.GetInstance(switchExpression.SwitchArms.Length); 1212var nestedConversion = this.ClassifyImplicitConversionFromExpression(arm.Value, destination, ref useSiteInfo); 1216return Conversion.NoConversion; 1222return Conversion.MakeSwitchExpression(innerConversions.ToImmutableAndFree()); 1224return Conversion.NoConversion; 1228private Conversion GetConditionalExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1233return Conversion.NoConversion; 1235var trueConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Consequence, destination, ref useSiteInfo); 1237return Conversion.NoConversion; 1239var falseConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Alternative, destination, ref useSiteInfo); 1241return Conversion.NoConversion; 1243return Conversion.MakeConditionalExpression(ImmutableArray.Create(trueConversion, falseConversion)); 1246private static Conversion ClassifyNullLiteralConversion(BoundExpression source, TypeSymbol destination) 1253return Conversion.NoConversion; 1261return Conversion.NullLiteral; 1271return Conversion.ImplicitReference; 1279return Conversion.NullToPointer; 1282return Conversion.NoConversion; 1285private static Conversion ClassifyImplicitConstantExpressionConversion(BoundExpression source, TypeSymbol destination) 1289return Conversion.ImplicitConstant; 1301return Conversion.ImplicitNullableWithImplicitConstantUnderlying; 1305return Conversion.NoConversion; 1308private Conversion ClassifyImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1312var tupleConversion = GetImplicitTupleLiteralConversion(source, destination, ref useSiteInfo); 1324var underlyingTupleConversion = GetImplicitTupleLiteralConversion(source, underlyingDestination, ref useSiteInfo); 1331return Conversion.NoConversion; 1334private Conversion ClassifyExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1338var tupleConversion = GetExplicitTupleLiteralConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1352var underlyingTupleConversion = GetExplicitTupleLiteralConversion(source, underlyingDestination, isChecked: isChecked, ref useSiteInfo, forCast); 1361return Conversion.NoConversion; 1416private Conversion ClassifyExplicitOnlyConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1427Conversion tupleConversion = ClassifyExplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1438Conversion fastConversion = FastClassifyConversion(sourceType, destination); 1445var conversion = ClassifyExplicitBuiltInOnlyConversion(sourceType, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1734internal Conversion ClassifyImplicitUserDefinedConversionForV6SwitchGoverningType(TypeSymbol sourceType, out TypeSymbol switchGoverningType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1766internal Conversion GetCallerLineNumberConversion(TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1779return Conversion.ImplicitEnumeration; 1782var constantConversion = ClassifyImplicitConstantExpressionConversion(intMaxValueLiteral, destination); 1799Conversion conversion = ClassifyStandardImplicitConversion(expectedAttributeType, destination, ref useSiteInfo); 1908Conversion conversion = ClassifyImplicitConversionFromType(source.Type, destination.Type, ref discardedUseSiteInfo); 1926public Conversion ConvertExtensionMethodThisArg(TypeSymbol parameterType, TypeSymbol thisType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool isMethodGroupConversion) 1929var conversion = this.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, thisType, parameterType, ref useSiteInfo, isMethodGroupConversion); 1930return IsValidExtensionMethodThisArgConversion(conversion) ? conversion : Conversion.NoConversion; 1936public Conversion ClassifyImplicitExtensionMethodThisArgConversion(BoundExpression sourceExpressionOpt, TypeSymbol sourceType, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool isMethodGroupConversion) 1946return Conversion.Identity; 1951return Conversion.Boxing; 1956return Conversion.ImplicitReference; 1961return Conversion.ImplicitSpan; 1970var tupleConversion = GetTupleLiteralConversion( 1987var tupleConversion = ClassifyTupleConversion( 1996return Conversion.NoConversion; 2008return Conversion.NoConversion; 2017public static bool IsValidExtensionMethodThisArgConversion(Conversion conversion) 2030foreach (var elementConversion in conversion.UnderlyingConversions) 2252private Conversion ClassifyImplicitNullableConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2265return Conversion.NoConversion; 2273return Conversion.NoConversion; 2278return Conversion.ImplicitNullableWithIdentityUnderlying; 2283return Conversion.ImplicitNullableWithImplicitNumericUnderlying; 2286var tupleConversion = ClassifyImplicitTupleConversion(unwrappedSource, unwrappedDestination, ref useSiteInfo); 2292return Conversion.NoConversion; 2295private delegate Conversion ClassifyConversionFromExpressionDelegate(ConversionsBase conversions, BoundExpression sourceExpression, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2296private delegate Conversion ClassifyConversionFromTypeDelegate(ConversionsBase conversions, TypeWithAnnotations source, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2298private Conversion GetImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2316private Conversion GetExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2334private Conversion GetTupleLiteralConversion( 2350return Conversion.NoConversion; 2357var argumentConversions = ArrayBuilder<Conversion>.GetInstance(arguments.Length); 2361var result = classifyConversion(this, argument, targetElementTypes[i], isChecked: isChecked, ref useSiteInfo, forCast: forCast); 2365return Conversion.NoConversion; 2374private Conversion ClassifyImplicitTupleConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2383Conversion conversion = conversions.ClassifyImplicitConversionFromType(s.Type, d.Type, ref u); 2387return Conversion.NoConversion; 2396private Conversion ClassifyExplicitTupleConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2405Conversion conversion = conversions.ClassifyConversionFromType(s.Type, d.Type, isChecked: isChecked, ref u, forCast); 2409return Conversion.NoConversion; 2418private Conversion ClassifyTupleConversion( 2434return Conversion.NoConversion; 2437var nestedConversions = ArrayBuilder<Conversion>.GetInstance(sourceTypes.Length); 2440var conversion = classifyConversion(this, sourceTypes[i], destTypes[i], isChecked: isChecked, ref useSiteInfo, forCast); 2444return Conversion.NoConversion; 2453private Conversion ClassifyExplicitNullableConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2468return Conversion.NoConversion; 2476return Conversion.ExplicitNullableWithIdentityUnderlying; 2481return Conversion.ExplicitNullableWithImplicitNumericUnderlying; 2486return Conversion.ExplicitNullableWithExplicitNumericUnderlying; 2489var tupleConversion = ClassifyExplicitTupleConversion(unwrappedSource, unwrappedDestination, isChecked: isChecked, ref useSiteInfo, forCast); 2497return Conversion.ExplicitNullableWithExplicitEnumerationUnderlying; 2502return Conversion.ExplicitNullableWithPointerToIntegerUnderlying; 2505return 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) 984protected virtual Conversion AnalyzeImplicitUnionConversions( 996return Conversion.NoConversion; 1006return Conversion.NoConversion; 1019return Conversion.CreateUnionConversion(UserDefinedConversionResult.Valid(u, best)); 1037Conversion fromConversion = EncompassingImplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo); 1038Conversion targetConversion = EncompassingImplicitConversion(declaringType, target, ref 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)

3051Conversion conversion = conversions.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(source, destination, ref useSiteInfo);

2634var c1 = m1.Result.ConversionForArg(i); 2635var c2 = m2.Result.ConversionForArg(i); 2887Conversion conv1, 2890Conversion conv2, 2940private BetterResult BetterConversionFromExpression(BoundExpression node, TypeSymbol t1, Conversion conv1, TypeSymbol t2, Conversion conv2, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool okToDowngradeToNeither) 3049TypeSymbol t1, Conversion conv1, 3050TypeSymbol t2, Conversion conv2, 3083TypeSymbol t1, CollectionExpressionTypeKind kind1, TypeSymbol elementType1, ImmutableArray<Conversion> underlyingElementConversions1, 3084TypeSymbol t2, CollectionExpressionTypeKind kind2, TypeSymbol elementType2, ImmutableArray<Conversion> underlyingElementConversions2, 3135var conversionToE1 = underlyingElementConversions1[i]; 3136var conversionToE2 = underlyingElementConversions2[i]; 3463return BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out okToDowngradeToNeither, betterConversionTargetRecursionLimit - 1); 3469Conversion conv1, 3471Conversion conv2, 3481Conversion conv1, 3483Conversion conv2, 3673private bool IsMethodGroupConversionIncompatibleWithDelegate(BoundMethodGroup node, NamedTypeSymbol delegateType, Conversion conv) 3766currentResult == BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out _, BetterConversionTargetRecursionLimit)); 4547ArrayBuilder<Conversion> conversions = null; 4552Conversion conversion; 4559conversion = Conversion.Identity; 4569conversion = Conversion.NoConversion; 4660conversions = ArrayBuilder<Conversion>.GetInstance(paramCount); 4661conversions.AddMany(Conversion.Identity, argumentPosition); 4672var conversionsArray = conversions != null ? conversions.ToImmutableAndFree() : default(ImmutableArray<Conversion>); 4694private Conversion CheckArgumentForApplicability( 4716return Conversion.NoConversion; 4728return Conversion.ImplicitDynamic; 4739return Conversion.Identity; 4744var conversion = forExtensionMethodThisArg ? 4748Conversion.ImplicitDynamic); 4755return Conversion.NoConversion; 4763return Conversion.Identity; 4767return Conversion.NoConversion;

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

171var sourceConversion = ConversionGroupOpt.Conversion.BestUnionConversionAnalysis.SourceConversion;

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

443public static Conversion GetConversion(BoundExpression? conversion, BoundValuePlaceholder? placeholder) 448return Conversion.NoConversion; 533return 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);

2392/// <returns>A <see cref="Conversion"/> that classifies the conversion from the 2394public Conversion ClassifyConversion(ITypeSymbol source, ITypeSymbol destination) 2440return Conversion.NoConversion; 2451return Conversion.NullLiteral; 2454return Conversion.NoConversion; 2457Conversion result = ClassifyConversion(sourceType, destination);

982return new CSharpTypeInfo(declarationTypeSymbol, declarationTypeSymbol, nullabilityInfo, nullabilityInfo, Conversion.Identity); 986return new CSharpTypeInfo(declarationInfo.Type, declarationInfo.Type, declarationInfo.Nullability, declarationInfo.Nullability, Conversion.Identity); 1024public Conversion GetConversion(SyntaxNode expression, CancellationToken cancellationToken = default(CancellationToken)) 1085public Conversion GetSpeculativeConversion(int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption) 2045return new CSharpTypeInfo(member.Type, member.Type, nullability: default, convertedNullability: default, Conversion.Identity); 2099Conversion conversion; 2148conversion = convertedSwitchConversion.IsValid ? convertedSwitchConversion : Conversion.NoConversion; 2155conversion = Conversion.Identity; 2166conversion = Conversion.MakeConditionalExpression(ImmutableArray<Conversion>.Empty); 2173conversion = Conversion.Identity; 2196conversion = Conversion.Identity; 2204conversion = Conversion.Identity; 2249conversion = Conversion.Identity; 2268conversion = Conversion.Identity; 2366return new CSharpTypeInfo(type, type, default, default, Conversion.Identity); 2819public abstract Conversion ClassifyConversion(ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false); 2837public Conversion ClassifyConversion(int position, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 2849return Conversion.NoConversion; 2875return Conversion.NoConversion; 2890internal abstract Conversion ClassifyConversionForCast(ExpressionSyntax expression, TypeSymbol destination); 2906internal Conversion ClassifyConversionForCast(int position, ExpressionSyntax expression, TypeSymbol destination) 2927return 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;

3058BoundConversion { Conversion: Conversion conversion, Operand: BoundConditionalAccess ca } when CanPropagateStateWhenNotNull(conversion) => ca, 3080protected 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, int, Location, ArrayBuilder&lt;VisitResult&gt;)"/>. 2864var conversion = conversionsWithoutNullability.ClassifyImplicitConversionFromType(actualType, targetType, ref discardedUseSiteInfo); 4086Conversion.Identity, // as only a nullable reinference is being done we expect an identity conversion 5097var conversions = ArrayBuilder<Conversion>.GetInstance(n); 5103(BoundExpression expressionNoConversion, Conversion conversion) = RemoveConversion(expression, includeExplicitConversions: false); 5146_ = VisitConversion(conversionOpt: null, conversionOperand: expressionsNoConversions[i], Conversion.Identity, targetTypeWithNullability: inferredType, operandType: expressionTypes[i], 5248Conversion conversion = conversionsWithoutNullability.ClassifyConversionFromExpression(placeholder, bestType, isChecked: returns[i].isChecked, ref discardedUseSiteInfo); 5443leftConversion = Conversion.Identity; 5463leftConversion = Conversion.Identity; 5565Conversion leftConversion, 5568Conversion rightConversion, 5583Conversion leftConversion, 5587Conversion rightConversion, 5620Conversion conversion, 5721var conversion = _conversions.ClassifyBuiltInConversion(derivedType, baseType, isChecked: false, ref discardedUseSiteInfo); 5731BoundExpression expr, BoundExpression operand, Conversion conversion, ParameterSymbol parameter, TypeWithState operandType, bool isLifted, 5755private void VisitBinaryOperatorOperandConversionAndPostConditions(BoundExpression expr, BoundExpression operand, Conversion conversion, ParameterSymbol parameter, TypeWithState operandType, bool isLifted) 5770Conversion leftConversion, 6216var conversion = GenerateConversionForConditionalOperator(node.LeftOperand, leftType, rightType, reportMismatch: true, isChecked: node.Checked); 6490(var consequence, var consequenceConversion, consequenceRValue) = visitConditionalOperand(consequenceState, originalConsequence); 6495(var alternative, var alternativeConversion, alternativeRValue) = visitConditionalOperand(alternativeState, originalAlternative); 6570TypeWithState consequenceRValue, TypeWithState alternativeRValue, BoundExpression consequence, Conversion consequenceConversion, bool consequenceEndReachable, 6571BoundExpression alternative, Conversion alternativeConversion, bool alternativeEndReachable, TypeWithAnnotations resultTypeWithAnnotations, bool wasTargetTyped) 6621Conversion consequenceConversion, 6624Conversion alternativeConversion, 6637(BoundExpression, Conversion, TypeWithState) visitConditionalOperand(LocalState state, BoundExpression operand) 6639Conversion conversion; 6670Conversion conversion, 7542(ImmutableArray<BoundExpression> argumentsNoConversions, ImmutableArray<Conversion> conversions) = RemoveArgumentConversions(arguments, refKindsOpt); 7556ImmutableArray<Conversion> conversions, 7658conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i], 7746ImmutableArray<Conversion> conversions, 8152Conversion conversion, 8566private (ImmutableArray<BoundExpression> arguments, ImmutableArray<Conversion> conversions) RemoveArgumentConversions( 8571var conversions = default(ImmutableArray<Conversion>); 8575var conversionsBuilder = ArrayBuilder<Conversion>.GetInstance(n); 8581var conversion = Conversion.Identity; 8968private static (BoundExpression expression, Conversion conversion) RemoveConversion(BoundExpression expr, bool includeExplicitConversions) 8987return (expr, Conversion.Identity); 9002return (expr, group?.Conversion ?? Conversion.Identity); 9006private Conversion GenerateConversionForConditionalOperator(BoundExpression sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool reportMismatch, bool isChecked) 9008var conversion = GenerateConversion(_conversions, sourceExpression, sourceType, destinationType, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: isChecked); 9017private Conversion GenerateConversion(Conversions conversions, BoundExpression? sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool fromExplicitCast, bool extensionMethodThisArgument, bool isChecked) 9201(BoundExpression operand, Conversion conversion) = RemoveConversion(node, includeExplicitConversions: true); 9256(BoundExpression operand, Conversion conversion) = RemoveConversion(expr, includeExplicitConversions: false); 9267Conversion conversion, TypeWithState operandType, 9299Func<TypeWithAnnotations, TypeWithState> visitConversionAsContinuation(BoundExpression expr, bool useLegacyWarnings, bool trackMembers, AssignmentKind assignmentKind, BoundExpression operand, Conversion conversion, TypeWithState operandType) 9452Conversion conversion, 9481void trackConvertedValue(FieldSymbol targetField, Conversion conversion, FieldSymbol valueField) 9765Conversion conversion, 9799conversion = Conversion.MakeNullableConversion(ConversionKind.ImplicitNullable, Conversion.Identity); 10125Conversion generated = GenerateConversion(_conversions, conversionOperand, operandType.Type, targetType, fromExplicitCast, extensionMethodThisArgument, isChecked: conversionOpt?.Checked ?? false); 10134Conversion generated = GenerateConversion(_conversions, conversionOperand, operandType.Type, targetType, fromExplicitCast, extensionMethodThisArgument, isChecked: conversionOpt?.Checked ?? false); 10386Conversion conversion, 10531Conversion conversion, 10772var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 11056CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, receiverParameter, receiverType); 11368private void VisitDeconstructionArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt = null) 11382private void VisitDeconstructMethodArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt) 11439var argConversion = RemoveConversion(invocation.Arguments[0], includeExplicitConversions: false).conversion; 11450var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 11491var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 12311Conversion conversion, 12569Conversion conversion = BoundNode.GetConversion(node.ElementConversion, node.ElementPlaceholder); 12832Conversion leftConversion = Conversion.Identity; 12870leftConversion = Conversion.Identity; 12900void afterLeftChildOfBoundUserDefinedConditionalLogicalOperatorHasBeenVisited(BoundUserDefinedConditionalLogicalOperator binary, BoundExpression leftOperand, Conversion leftConversion) 13390private void CheckExtensionMethodThisNullability(BoundExpression expr, Conversion conversion, ParameterSymbol parameter, TypeWithState result)

1013var conversions = ArrayBuilder<Conversion>.GetInstance(numSwitchArms); 1031(BoundExpression expression, Conversion conversion) = RemoveConversion(arm.Value, includeExplicitConversions: false); 1088ArrayBuilder<Conversion> conversions, 1133ArrayBuilder<Conversion> conversions,

3003public BoundConversion(SyntaxNode syntax, BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, InConversionGroupFlags inConversionGroupFlags, TypeSymbol type, bool hasErrors = false) 3026public Conversion Conversion { get; } 3037public 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); 776Conversion c = _bound.ClassifyEmitConversion(receiver, _objectType); 938Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 948Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 965Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 975Conversion c = _bound.ClassifyEmitConversion(fieldInfo, MemberInfoType); 1112Conversion c = _bound.ClassifyEmitConversion(args, iEnumerableType); 1256Conversion c = _bound.ClassifyEmitConversion(node, _objectType);

489Conversion 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);

221input = _factory.Convert(inputType, input, Conversion.Identity); 228Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo); 407_factory.Convert(operandType, rewrittenExpr, Conversion.PointerToVoid), 408_factory.Convert(operandType, new BoundLiteral(syntax, ConstantValue.Null, objectType), Conversion.NullToPointer), 454Conversion c = _factory.ClassifyEmitConversion(input, comparisonType); 519_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) 206Conversion conversion; 560Conversion c = _factory.ClassifyEmitConversion(arrayOrList, collectionType); 763var spreadElementConversion = expressionStatement.Expression is BoundConversion { Conversion: var actualConversion } ? actualConversion : Conversion.Identity;

901Conversion.Boxing,

264Conversion conversion, 283Conversion.Identity, 300Conversion conversion, 427conversion = Conversion.ExplicitNumeric; 478var outerConversion = Conversion.ImplicitNullableWithIdentityUnderlying; 644Conversion c = _factory.ClassifyEmitConversion(rewrittenOperand, parameterType); 808Conversion conversion = MakeConversion(rewrittenOperand, rewrittenType, @checked: @checked, _compilation, _diagnostics, acceptFailingConversion); 824private static Conversion MakeConversion( 834Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo); 858Conversion conversion, 1015Conversion conversion, 1103Conversion conversion, 1159Conversion conversion, 1184rewrittenOperand = BoundConversion.SynthesizedNonUserDefined(syntax, rewrittenOperand, Conversion.ImplicitEnumeration, rewrittenOperandType); 1197var userDefinedConversion = new Conversion(conversionKind, method, false); 1212Conversion conversion, 1274Conversion conversion, 1306Conversion conversion, 1346Conversion conversion, 1408Conversion conversion, 1464Conversion conversion, 1471Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked); 1554Conversion conversion) 1580Conversion conversion, 1836var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1853private Conversion TryMakeConversion(SyntaxNode syntax, Conversion conversion, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1863Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1866return Conversion.NoConversion; 1869Conversion toConversion = TryMakeConversion(syntax, conversion.UserDefinedToConversion, meth.ReturnType, toType, @checked: @checked); 1872return Conversion.NoConversion; 1884var resultConversion = new Conversion(result, conversion.IsImplicit); 1901return Conversion.NoConversion; 1915return Conversion.NoConversion; 1932return Conversion.NoConversion; 1945return Conversion.NoConversion; 1959private Conversion TryMakeConversion(SyntaxNode syntax, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1962var result = TryMakeConversion(syntax, _compilation.Conversions.ClassifyConversionFromType(fromType, toType, isChecked: @checked, ref useSiteInfo), fromType, toType, @checked: @checked); 1970private Conversion TryMakeUserDefinedConversion(SyntaxNode syntax, MethodSymbol meth, TypeSymbol fromType, TypeSymbol toType, bool @checked, bool isImplicit) 1974Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked); 1977return Conversion.NoConversion; 1980Conversion toConversion = TryMakeConversion(syntax, meth.ReturnType, toType, @checked: @checked); 1983return 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);

363Conversion receiverConversion = enumeratorType.IsStructType() ? 364Conversion.Boxing : 365Conversion.ImplicitReference; 505private BoundExpression ConvertReceiverForInvocation(CSharpSyntaxNode syntax, BoundExpression receiver, MethodSymbol method, Conversion receiverConversion, TypeSymbol convertedReceiverType) 1224private 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, 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, bool explicitCastInCode = true) 1790rewrittenExpr = Convert(objectType, rewrittenExpr, Conversion.Boxing);

1118Conversion conversion = boundConversion.Conversion; 1183Conversion conversion = BoundNode.GetConversion(boundAsOperator.OperandConversion, boundAsOperator.OperandPlaceholder); 1349var elementConversion = BoundNode.GetConversion(iteratorItem, element.ElementPlaceholder); 1435Conversion inConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.LeftConversion, boundCompoundAssignmentOperator.LeftPlaceholder); 1436Conversion outConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.FinalConversion, boundCompoundAssignmentOperator.FinalPlaceholder); 1659Conversion valueConversion = BoundNode.GetConversion(boundNullCoalescingOperator.LeftConversion, boundNullCoalescingOperator.LeftPlaceholder); 1664valueConversion = Conversion.Identity; 1972inlineArrayConversion: 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);

4883Conversion c = compilation.Conversions.ClassifyImplicitConversionFromType(parameterType.Type, compilation.GetSpecialType(SpecialType.System_Object), 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);

49Conversion c = F.Compilation.Conversions.ClassifyImplicitConversionFromType(parameter.Type, valueProperty.Type, ref useSiteInfo); 66public static bool IsValidParameterTypeConversion(Conversion c)

90var outerConversion = outerConversionOperation.GetConversion(); 103var innerConversion = innerConversionOperation.GetConversion();

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,

11public static bool IsIdentityOrImplicitReference(this Conversion conversion) 14public 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);

8555Conversion conversion = model.GetConversion(ten); 8567Assert.Equal(Conversion.NoConversion, conversion.UserDefinedFromConversion); 8568Assert.Equal(Conversion.NoConversion, conversion.UserDefinedToConversion); 8880Conversion conversion = model.GetConversion(cast); 9310Conversion conversion = model.GetConversion(x1); 9315Assert.Equal(Conversion.NoConversion, conversion.UserDefinedFromConversion); 9316Assert.Equal(Conversion.NoConversion, conversion.UserDefinedToConversion); 10719Conversion conversion = model.GetConversion(ten); 10731Assert.Equal(Conversion.NoConversion, conversion.UserDefinedFromConversion); 10732Assert.Equal(Conversion.NoConversion, conversion.UserDefinedToConversion); 10908Conversion conversion = model.GetConversion(cast); 11061Conversion conversion = model.GetConversion(x1); 11066Assert.Equal(Conversion.NoConversion, conversion.UserDefinedFromConversion); 11067Assert.Equal(Conversion.NoConversion, conversion.UserDefinedToConversion); 11366Conversion conversion = model.GetConversion(tuple); 11437Conversion conversion = model.GetConversion(tuple); 11508Conversion conversion = model.GetConversion(tuple);

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();

16077var conversion = model.GetConversion(returnValue); 16083var underlyingConversion = conversion.UnderlyingConversions[0]; 16153var conversion = model.GetConversion(returnValue); 16159var underlyingConversion = conversion.UnderlyingConversions[0]; 16226var conversion = model.GetConversion(collection); 16290var castConversion = model.GetConversion(cast); 16295var conversion = model.GetConversion(value); 16416var castConversion = model.GetConversion(cast); 16421var conversion = model.GetConversion(value); 16498var conversion = model.GetConversion(nestedCollection); 16587var conversion = model.GetConversion(nestedCollection); 16593var underlyingConversion = conversion.UnderlyingConversions[0]; 16941var conversion = model.GetConversion(expr); 29140Conversion conversion = conversionOperation.GetConversion(); 29142AssertEx.SequenceEqual([Conversion.Boxing, Conversion.Boxing], conversion.UnderlyingConversions); 29200var expectedConversion = new Conversion(ConversionKind.CollectionExpression, nestedConversions: ImmutableArray.Create(Conversion.Identity, Conversion.Identity)); 29201Conversion actual = conversionOperation.GetConversion(); 29203AssertEx.SequenceEqual(ImmutableArray.Create(Conversion.Identity, Conversion.Identity), actual.UnderlyingConversions); 29444Assert.Equal(Conversion.Boxing, spread.GetElementConversion()); 29466Assert.Equal(Conversion.ImplicitReference, spread.GetElementConversion()); 31031var conversion1 = model.GetConversion(collections[0]); 31035var conversion2 = model.GetConversion(collections[1]); 31075var conversion1 = model.GetConversion(collections[0]); 31079var conversion2 = model.GetConversion(collections[1]); 31124var conversion1 = model.GetConversion(collections[0]); 31129var conversion2 = model.GetConversion(collections[1]); 31165var conversion1 = model.GetConversion(collections[0]); 31169var conversion2 = model.GetConversion(collections[1]); 31208var conversion1 = model.GetConversion(collections[0]); 31212var conversion2 = model.GetConversion(collections[1]); 31251var conversion = model.GetConversion(collection); 31291var conversion = model.GetConversion(collection); 31323var conversion = model.GetConversion(collection); 31357var conversion1 = model.GetConversion(collections[0]); 31361var conversion2 = model.GetConversion(collections[1]); 31369var conversion3 = model.GetConversion(collections[2]); 31377var conversion4 = model.GetConversion(collections[3]); 31410var conversion1 = model.GetConversion(collections[0]); 31414var conversion2 = model.GetConversion(collections[1]); 31422var conversion3 = model.GetConversion(collections[2]); 31430var conversion4 = model.GetConversion(collections[3]); 31476var conversion1 = model.GetConversion(collections[0]); 31479var conversion2 = model.GetConversion(collections[1]); 31486var conversion3 = model.GetConversion(collections[2]); 31493var conversion4 = model.GetConversion(collections[3]); 31537var conversion1 = model.GetConversion(collections[0]); 31540var conversion2 = model.GetConversion(collections[1]); 31547var conversion3 = model.GetConversion(collections[2]); 31554var conversion4 = model.GetConversion(collections[3]); 31613var conversion1 = model.GetConversion(collection); 31656var conversion1 = model.GetConversion(collections[0]); 31661var conversion2 = model.GetConversion(collections[1]); 31703var conversion = model.GetConversion(collection); 35087var collectionConversion = model.GetConversion(collection); 35093var elementConversion = model.GetConversion(element); 35184var elementConversion1 = model.GetConversion(element1); 35190var elementConversion2 = model.GetConversion(element2); 35226var elementConversion1 = model.GetConversion(element1); 35232var elementConversion2 = model.GetConversion(element2); 35272var elementConversion1 = model.GetConversion(element1); 35278var elementConversion2 = model.GetConversion(element2);

298var conversion = model.GetConversion(expr);

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)

90var outerConversion = outerConversionOperation.GetConversion(); 103var innerConversion = innerConversionOperation.GetConversion();

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);

214var conversion = model.GetConversion(initializer1); 219var classifiedConversion = comp.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType!); 296var conversion = model.GetConversion(literal); 304var classifiedConversion = model.ClassifyConversion(literal, typeInfo.ConvertedType); 356var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 364var underlying = conversion.UnderlyingConversions.Single(); 407var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 459var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 509var conversion = model.ClassifyConversion(conv.Expression, typeInfoOuter.Type!); 606var conversion = model.GetConversion(decl); 610var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 846var conversion = model.GetConversion(decl); 852var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 904var conversion = model.GetConversion(initializer); 911var 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);

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

7268var conv = model.GetConversion(syntax); 7271Assert.Equal(Conversion.Identity, conv); 7335var conv = model.GetConversion(syntax); 7338Assert.Equal(Conversion.Identity, conv); 7373var conv = model.GetConversion(syntax); 7376Assert.Equal(Conversion.Identity, conv); 7415var conv = model.GetConversion(syntax); 7418Assert.Equal(Conversion.Identity, conv); 7546var conv = model.GetConversion(syntax); 7549Assert.Equal(Conversion.Identity, conv); 8350var conv = model.GetConversion(node); 8395var conv = model.GetConversion(value); 8885Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 8920Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 9347Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 10238Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 10314Assert.Equal(Conversion.PointerToVoid, summary0.ImplicitConversion); 10321Assert.Equal(Conversion.PointerToVoid, summary1.ImplicitConversion); 10327Assert.Equal(Conversion.PointerToVoid, summary2.ImplicitConversion); 10640Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10652Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 10702Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10714Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 10762Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 10774Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 11314Assert.Equal(Conversion.PointerToVoid, stackAllocSummary.ImplicitConversion); 11326Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 11338Assert.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);

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

11public static bool IsIdentityOrImplicitReference(this Conversion conversion) 14public 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);

858CSharp.Conversion csharpConversion = CSharp.CSharpExtensions.GetConversion(operation); 1187var inConversionInternal = CSharp.CSharpExtensions.GetInConversion(operation); 1188var outConversionInternal = CSharp.CSharpExtensions.GetOutConversion(operation);

826Conversion 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);

11public static bool IsIdentityOrImplicitReference(this Conversion conversion) 14public 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);

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