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

158return new Conversion(this.Kind, conversionMethod, isExtensionMethod: IsExtensionMethod); 166return new Conversion( 222return new Conversion(kind); 225internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 226internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 227internal static Conversion Identity => new Conversion(ConversionKind.Identity); 228internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 229internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 230internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 231internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 232internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 233internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 234internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 235internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 236internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 237internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 238internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 239internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 240internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 241internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 242internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 243internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 244internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 245internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 246internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 247internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 248internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 249internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 250internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 251internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 252internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 253internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 254internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 255internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 280return new Conversion(ConversionKind.StackAllocToPointerType, ImmutableArray.Create(underlyingConversion)); 285return new Conversion(ConversionKind.StackAllocToSpanType, ImmutableArray.Create(underlyingConversion)); 318return new Conversion(kind, nested); 323return new Conversion(ConversionKind.SwitchExpression, innerConversions); 328return new Conversion(ConversionKind.ConditionalExpression, innerConversions);

382return new Conversion(ConversionKind.MethodGroup, method, methodGroup.IsExtensionMethodGroup);

758return new Conversion(conversionResult, isImplicit: true); 843return new Conversion(conversionResult, isImplicit: false); 1205return new Conversion(ConversionKind.ImplicitNullable, Conversion.ImplicitConstantUnderlying); 1235return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1266return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(underlyingTupleConversion)); 1608return new Conversion(result, isImplicit: true); 2115return new Conversion(ConversionKind.ImplicitNullable, Conversion.IdentityUnderlying); 2120return new Conversion(ConversionKind.ImplicitNullable, Conversion.ImplicitNumericUnderlying); 2126return new Conversion(ConversionKind.ImplicitNullable, ImmutableArray.Create(tupleConversion)); 2208return new Conversion(kind, argumentConversions.ToImmutableAndFree()); 2281return new Conversion(kind, nestedConversions.ToImmutableAndFree()); 2307return new Conversion(ConversionKind.ExplicitNullable, Conversion.IdentityUnderlying); 2312return new Conversion(ConversionKind.ExplicitNullable, Conversion.ImplicitNumericUnderlying); 2317return new Conversion(ConversionKind.ExplicitNullable, Conversion.ExplicitNumericUnderlying); 2323return new Conversion(ConversionKind.ExplicitNullable, ImmutableArray.Create(tupleConversion)); 2328return new Conversion(ConversionKind.ExplicitNullable, Conversion.ExplicitEnumerationUnderlying); 2333return new Conversion(ConversionKind.ExplicitNullable, Conversion.PointerToIntegerUnderlying);

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

464var outerConversion = new Conversion(ConversionKind.ImplicitNullable, Conversion.IdentityUnderlying); 990var result = new BoundConversion(syntax, rewrittenOperand, new Conversion(conversionKind, method, false), @checked, explicitCastInCode: explicitCastInCode, conversionGroup, constantValueOpt: null, rewrittenType); 1585var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1630var resultConversion = new Conversion(result, conversion.IsImplicit); 1730return new Conversion(result, isImplicit);

88var inConversion = new Conversion(ConversionKind.ImplicitUserDefined, inSymbol, false); 89var outConversion = new Conversion(ConversionKind.ImplicitUserDefined, outSymbol, false);

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

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

826Conversion conversion = conversions.ClassifyBuiltInConversion((TypeSymbol)argument.TypeInternal, parameter.Type, isChecked: false, ref discardedUseSiteInfo);

415var conversion = this.Conversions.ClassifyImplicitConversionFromType(awaiterType, INotifyCompletion, ref useSiteInfo);

24var conversion = Conversions.ClassifyConversionFromExpression(source, destination, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 32Conversion conversion, 42Conversion conversion, 54Conversion conversion, 80static bool filterConversion(Conversion conversion) 95Conversion conversion, 270void reportUseSiteDiagnostics(Conversion conversion) 282void reportUseSiteDiagnosticsForUnderlyingConversions(Conversion conversion) 288foreach (var underlying in underlyingConversions) 303void reportUseSiteDiagnosticsForSelfAndUnderlyingConversions(Conversion conversion) 312internal void CheckConstraintLanguageVersionAndRuntimeSupportForConversion(SyntaxNodeOrToken syntax, Conversion conversion, BindingDiagnosticBag diagnostics) 342SyntaxNode syntax, BoundUnconvertedObjectCreationExpression node, Conversion conversion, bool isCast, TypeSymbol destination, 364expr is BoundBadExpression ? Conversion.NoConversion : conversion, 413Conversion? conversionIfTargetTyped, 419ImmutableArray<Conversion> underlyingConversions = conversionIfTargetTyped.GetValueOrDefault().UnderlyingConversions; 451private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, Conversion? conversionIfTargetTyped, BindingDiagnosticBag diagnostics, bool hasErrors = false) 454Conversion conversion = conversionIfTargetTyped ?? Conversion.Identity; 456ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions; 480Conversion conversion, 571Conversion toConversion = conversion.UserDefinedToConversion; 645private BoundExpression CreateFunctionTypeConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics) 693private BoundExpression CreateAnonymousFunctionConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics) 720private BoundExpression CreateMethodGroupConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics) 865private BoundExpression CreateStackAllocConversion(SyntaxNode syntax, BoundExpression source, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics) 889var underlyingConversion = conversion.UnderlyingConversions.Single(); 893private BoundExpression CreateTupleLiteralConversion(SyntaxNode syntax, BoundTupleLiteral sourceTuple, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics) 900var conversionWithoutNullable = conversion; 955var elementConversion = underlyingConversions[i]; 990Conversion.Identity, 1011private BoundMethodGroup FixMethodGroupWithTypeOrValue(BoundMethodGroup group, Conversion conversion, BindingDiagnosticBag diagnostics) 1435Conversion conversion, 1501out Conversion conversion) 1505conversion = Conversion.NoConversion; 1533Conversion conversion,

132new BoundConversion(boundRHS.Syntax, boundRHS, Conversion.Deconstruction, @checked: false, explicitCastInCode: false, conversionGroupOpt: null, 139Conversion conversion; 248out Conversion conversion) 252conversion = Conversion.Deconstruction; 300Conversion nestedConversion;

1186Conversion conversion = this.Conversions.ClassifyConversionFromExpression(argument, typedReferenceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1235Conversion conversion = this.Conversions.ClassifyConversionFromExpression(argument, typedReferenceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 2371Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, intType, ref useSiteInfo); 2477Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(boundOperand, indexType, ref useSiteInfo); 2492Conversion conversion = this.Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 2509Conversion conversion, 2645var elementConversion = Conversions.ClassifyConversionFromExpression(argument, targetElementType, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 2671var underlyingConversion = Conversions.ClassifyBuiltInConversion(operand.Type, underlyingTargetTypeWithAnnotations.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 3170var kind = result.ConversionForArg(arg); 4541var conversion = this.Conversions.ClassifyConversionFromExpression(unboundLambda, type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 4581Conversion conversion; 4614Conversion conv = Conversions.MethodGroupConversion(argument.Syntax, methodGroup, type, ref useSiteInfo); 5887Conversion conversion = this.Conversions.ClassifyConversionFromExpression(classCreation, interfaceType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 7569Conversion.ImplicitNumeric, 8106Conversion failedConversion = this.Conversions.ClassifyConversionFromExpression(index, int32, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 8161Conversion conversion = this.Conversions.ClassifyImplicitConversionFromExpression(expr, targetType, ref useSiteInfo);

857var interpolatedStringConversion = memberAnalysisResult.ConversionForArg(interpolatedStringArgNum);

1429Conversion conversion = Conversions.ClassifyConversionFromExpression(defaultValue, parameterType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo);

64var finalDynamicConversion = this.Compilation.Conversions.ClassifyConversionFromExpression(placeholder, left.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 223Conversion rightToLeftConversion = this.Conversions.ClassifyConversionFromExpression(right, leftType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 270Conversion argumentConversion = this.Conversions.ClassifyConversionFromExpression(right, delegateType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 789var conversion = this.Conversions.ClassifyConversionFromExpression(right, left.Type, isChecked: CheckOverflowAtRuntime, ref discardedUseSiteInfo); 1037var implicitConversion = Conversions.ClassifyImplicitConversionFromExpression(left, booleanType, ref useSiteInfo); 1245var conversion = this.Conversions.ClassifyConversionFromType(argumentType, op.GetParameterType(0), isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 3263Conversion conv = Conversions.ClassifyConversionFromExpression(operand, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 3285Conversion conversion = Conversions.ClassifyBuiltInConversion(operandType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 3713Conversion.NullLiteral, 3752Conversion conversion = Conversions.ClassifyBuiltInConversion(operandType, targetType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 3990var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType0, ref useSiteInfo); 4008var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, optLeftType, ref useSiteInfo); 4045Conversion leftConversionClassification; 4125var underlyingRightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, underlyingLeftType, ref useSiteInfo); 4139var rightConversion = Conversions.ClassifyImplicitConversionFromExpression(rightOperand, leftType, ref useSiteInfo);

424var convertedExpression = BindExpressionOrTypeForPattern(inputType, innerExpression, ref hasErrors, diagnostics, out var constantValueOpt, out bool wasExpression, out Conversion patternConversion); 453private bool ShouldBlockINumberBaseConversion(Conversion patternConversion, TypeSymbol inputType) 504out Conversion patternExpressionConversion) 517patternExpressionConversion = Conversion.NoConversion; 532out Conversion patternExpressionConversion) 538patternExpressionConversion = Conversion.NoConversion; 549out Conversion patternExpressionConversion) 585out Conversion patternExpressionConversion) 631patternExpressionConversion = Conversion.NoConversion; 638patternExpressionConversion = Conversion.NoConversion; 667patternExpressionConversion = Conversion.NoConversion; 757Conversions, inputType, patternType, ref useSiteInfo, out Conversion conversion, operandConstantValue: null, operandCouldBeNull: true); 798out Conversion conversion, 808conversion = Conversion.Identity; 1622BoundExpression value = BindExpressionForPattern(inputType, node.Expression, ref hasErrors, diagnostics, out var constantValueOpt, out _, out Conversion patternConversion);

1376Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(pointerType, declType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1910internal BoundExpression GenerateConversionForAssignment(TypeSymbol targetType, BoundExpression expression, BindingDiagnosticBag diagnostics, out Conversion conversion, ConversionForAssignmentFlags flags = ConversionForAssignmentFlags.None) 2196Conversion conversion, TypeSymbol sourceType, TypeSymbol targetType, ConstantValue sourceConstantValueOpt = null) 2266Conversion conversion, 2384var conversion = this.Conversions.ClassifyImplicitConversionFromExpression(expr, targetType, ref useSiteInfo); 2484var elementConversion = Conversions.ClassifyImplicitConversionFromExpression(argument, targetElementType, ref discardedUseSiteInfo); 2546return BoundConversion.Synthesized(node, BindToTypeForErrorRecovery(expr), Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, boolean, hasErrors: true); 2571var conversion = this.Conversions.ClassifyConversionFromExpression(expr, boolean, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 2612return BoundConversion.Synthesized(node, expr, Conversion.NoConversion, false, explicitCastInCode: false, conversionGroupOpt: null, ConstantValue.NotAvailable, boolean, hasErrors: true); 3034Conversion conversion; 3043conversion = Conversion.NoConversion;

1529var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo);

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

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

447Conversion elementConversionClassification = this.Conversions.ClassifyConversionFromType(inferredType.Type, iterationVariableType.Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo, forCast: true); 501Conversion collectionConversionClassification = this.Conversions.ClassifyConversionFromExpression(collectionExpr, builder.CollectionType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 502Conversion currentConversionClassification = this.Conversions.ClassifyConversionFromType(builder.CurrentPropertyGetter.ReturnType, builder.ElementType, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1320var collectionConversion = this.Conversions.ClassifyConversionFromExpression(collectionExpr, result.Parameters[0].Type, isChecked: CheckOverflowAtRuntime, ref useSiteInfo); 1560var conversion = this.Conversions.ClassifyImplicitConversionFromType(type, implementedNonGeneric, ref useSiteInfo);

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

19public readonly struct Conversion : IEquatable<Conversion>, IConvertibleConversion 33ImmutableArray<Conversion> nestedConversions) 47internal readonly ImmutableArray<Conversion> _nestedConversionsOpt; 130internal Conversion(ConversionKind kind, ImmutableArray<Conversion> nestedConversions) 149internal Conversion SetConversionMethod(MethodSymbol conversionMethod) 161internal Conversion SetArrayIndexConversionForDynamic() 219internal static Conversion GetTrivialConversion(ConversionKind kind) 225internal static Conversion UnsetConversion => new Conversion(ConversionKind.UnsetConversionKind); 226internal static Conversion NoConversion => new Conversion(ConversionKind.NoConversion); 227internal static Conversion Identity => new Conversion(ConversionKind.Identity); 228internal static Conversion ImplicitConstant => new Conversion(ConversionKind.ImplicitConstant); 229internal static Conversion ImplicitNumeric => new Conversion(ConversionKind.ImplicitNumeric); 230internal static Conversion ImplicitReference => new Conversion(ConversionKind.ImplicitReference); 231internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration); 232internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow); 233internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation); 234internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction); 235internal static Conversion Boxing => new Conversion(ConversionKind.Boxing); 236internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral); 237internal static Conversion DefaultLiteral => new Conversion(ConversionKind.DefaultLiteral); 238internal static Conversion NullToPointer => new Conversion(ConversionKind.ImplicitNullToPointer); 239internal static Conversion PointerToVoid => new Conversion(ConversionKind.ImplicitPointerToVoid); 240internal static Conversion PointerToPointer => new Conversion(ConversionKind.ExplicitPointerToPointer); 241internal static Conversion PointerToInteger => new Conversion(ConversionKind.ExplicitPointerToInteger); 242internal static Conversion IntegerToPointer => new Conversion(ConversionKind.ExplicitIntegerToPointer); 243internal static Conversion Unboxing => new Conversion(ConversionKind.Unboxing); 244internal static Conversion ExplicitReference => new Conversion(ConversionKind.ExplicitReference); 245internal static Conversion IntPtr => new Conversion(ConversionKind.IntPtr); 246internal static Conversion ExplicitEnumeration => new Conversion(ConversionKind.ExplicitEnumeration); 247internal static Conversion ExplicitNumeric => new Conversion(ConversionKind.ExplicitNumeric); 248internal static Conversion ImplicitDynamic => new Conversion(ConversionKind.ImplicitDynamic); 249internal static Conversion ExplicitDynamic => new Conversion(ConversionKind.ExplicitDynamic); 250internal static Conversion InterpolatedString => new Conversion(ConversionKind.InterpolatedString); 251internal static Conversion InterpolatedStringHandler => new Conversion(ConversionKind.InterpolatedStringHandler); 252internal static Conversion Deconstruction => new Conversion(ConversionKind.Deconstruction); 253internal static Conversion PinnedObjectToPointer => new Conversion(ConversionKind.PinnedObjectToPointer); 254internal static Conversion ImplicitPointer => new Conversion(ConversionKind.ImplicitPointer); 255internal static Conversion FunctionType => new Conversion(ConversionKind.FunctionType); 259internal static ImmutableArray<Conversion> IdentityUnderlying => ConversionSingletons.IdentityUnderlying; 260internal static ImmutableArray<Conversion> ImplicitConstantUnderlying => ConversionSingletons.ImplicitConstantUnderlying; 261internal static ImmutableArray<Conversion> ImplicitNumericUnderlying => ConversionSingletons.ImplicitNumericUnderlying; 262internal static ImmutableArray<Conversion> ExplicitNumericUnderlying => ConversionSingletons.ExplicitNumericUnderlying; 263internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying => ConversionSingletons.ExplicitEnumerationUnderlying; 264internal static ImmutableArray<Conversion> PointerToIntegerUnderlying => ConversionSingletons.PointerToIntegerUnderlying; 270internal static ImmutableArray<Conversion> IdentityUnderlying = ImmutableArray.Create(Identity); 271internal static ImmutableArray<Conversion> ImplicitConstantUnderlying = ImmutableArray.Create(ImplicitConstant); 272internal static ImmutableArray<Conversion> ImplicitNumericUnderlying = ImmutableArray.Create(ImplicitNumeric); 273internal static ImmutableArray<Conversion> ExplicitNumericUnderlying = ImmutableArray.Create(ExplicitNumeric); 274internal static ImmutableArray<Conversion> ExplicitEnumerationUnderlying = ImmutableArray.Create(ExplicitEnumeration); 275internal static ImmutableArray<Conversion> PointerToIntegerUnderlying = ImmutableArray.Create(PointerToInteger); 278internal static Conversion MakeStackAllocToPointerType(Conversion underlyingConversion) 283internal static Conversion MakeStackAllocToSpanType(Conversion underlyingConversion) 288internal static Conversion MakeNullableConversion(ConversionKind kind, Conversion nestedConversion) 292ImmutableArray<Conversion> nested; 321internal static Conversion MakeSwitchExpression(ImmutableArray<Conversion> innerConversions) 326internal static Conversion MakeConditionalExpression(ImmutableArray<Conversion> innerConversions) 355internal ImmutableArray<Conversion> UnderlyingConversions 359return _uncommonData?._nestedConversionsOpt ?? default(ImmutableArray<Conversion>); 380foreach (var underlying in underlyingConversions) 408foreach (var underlying in underlyingConversions) 497foreach (var conv in nestedConversionsOpt) 971internal Conversion UserDefinedFromConversion 976return best == null ? Conversion.NoConversion : best.SourceConversion; 983internal Conversion UserDefinedToConversion 988return best == null ? Conversion.NoConversion : best.TargetConversion; 1052/// This is a lossy conversion; it is not possible to recover the original <see cref="Conversion"/> 1072/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1074/// <param name="obj">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1075/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1078return obj is Conversion && this.Equals((Conversion)obj); 1082/// Determines whether the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object. 1084/// <param name="other">The <see cref="Conversion"/> object to compare with the current <see cref="Conversion"/> object.</param> 1085/// <returns>true if the specified <see cref="Conversion"/> object is equal to the current <see cref="Conversion"/> object; otherwise, false.</returns> 1086public bool Equals(Conversion other) 1092/// Returns a hash code for the current <see cref="Conversion"/> object. 1094/// <returns>A hash code for the current <see cref="Conversion"/> object.</returns> 1101/// Returns true if the specified <see cref="Conversion"/> objects are equal and false otherwise. 1103/// <param name="left">The first <see cref="Conversion"/> object.</param> 1104/// <param name="right">The second <see cref="Conversion"/> object.</param> 1106public static bool operator ==(Conversion left, Conversion right) 1112/// Returns false if the specified <see cref="Conversion"/> objects are equal and true otherwise. 1114/// <param name="left">The first <see cref="Conversion"/> object.</param> 1115/// <param name="right">The second <see cref="Conversion"/> object.</param> 1117public static bool operator !=(Conversion left, Conversion right) 1127TreeDumperNode Dump(Conversion self)

44public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 49return Conversion.NoConversion; 55return Conversion.NoConversion; 105var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ? 106Conversion.NoConversion : 113public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 122var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ? 123Conversion.NoConversion : 129protected override Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 133return Conversion.InterpolatedStringHandler; 138return Conversion.NoConversion; 146? Conversion.InterpolatedString : Conversion.NoConversion; 278public Conversion MethodGroupConversion(SyntaxNode syntax, MethodGroup methodGroup, NamedTypeSymbol delegateType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 297var conversion = ToConversion(result, methodGroup, delegateType.DelegateInvokeMethod.ParameterCount); 328private static Conversion ToConversion(OverloadResolutionResult<MethodSymbol> result, MethodGroup methodGroup, int parameterCount) 348return Conversion.NoConversion; 355return Conversion.NoConversion; 361return Conversion.NoConversion; 366return Conversion.NoConversion; 385public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 393var pointerConversion = ClassifyImplicitConversionFromType(sourceAsPointer, destination, ref useSiteInfo); 397return Conversion.MakeStackAllocToPointerType(pointerConversion); 405var spanConversion = ClassifyImplicitConversionFromType(spanType_T, destination, ref useSiteInfo); 409return Conversion.MakeStackAllocToSpanType(spanConversion); 415return Conversion.NoConversion;

66public abstract Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 68public abstract Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 70public abstract Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 74protected abstract Conversion GetInterpolatedStringConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo); 89public Conversion ClassifyImplicitConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 100return Conversion.Identity; 103Conversion conversion = ClassifyImplicitBuiltInConversionFromExpression(sourceExpression, sourceType, destination, ref useSiteInfo); 112Conversion fastConversion = FastClassifyConversion(sourceType, destination); 133return Conversion.FunctionType; 160public Conversion ClassifyImplicitConversionFromType(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 168return Conversion.Identity; 172Conversion fastConversion = FastClassifyConversion(source, destination); 175return fastConversion.IsImplicit ? fastConversion : Conversion.NoConversion; 179Conversion conversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 195public Conversion ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 208Conversion.FunctionType : 209Conversion.NoConversion; 213return Conversion.NoConversion; 225public Conversion ClassifyConversionFromExpressionType(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 233return Conversion.ImplicitDynamic; 239private static bool TryGetVoidConversion(TypeSymbol source, TypeSymbol destination, out Conversion conversion) 250conversion = Conversion.Identity; 257conversion = Conversion.NoConversion; 274public Conversion ClassifyConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast = false) 280if (TryGetVoidConversion(sourceExpression.Type, destination, out var conversion)) 290var result = ClassifyImplicitConversionFromExpression(sourceExpression, destination, ref useSiteInfo); 308public Conversion ClassifyConversionFromType(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast = false) 313if (TryGetVoidConversion(source, destination, out var voidConversion)) 324Conversion fastConversion = FastClassifyConversion(source, destination); 331Conversion conversion1 = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 338Conversion conversion = GetImplicitUserDefinedConversion(source, destination, ref useSiteInfo); 366private Conversion ClassifyConversionFromExpressionForCast(BoundExpression source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 372Conversion implicitConversion = ClassifyImplicitConversionFromExpression(source, destination, ref useSiteInfo); 378Conversion explicitConversion = ClassifyExplicitOnlyConversionFromExpression(source, destination, isChecked: isChecked, ref useSiteInfo, forCast: true); 420private Conversion ClassifyConversionFromTypeForCast(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 426Conversion fastConversion = FastClassifyConversion(source, destination); 432Conversion implicitBuiltInConversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 438Conversion explicitBuiltInConversion = ClassifyExplicitBuiltInOnlyConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast: true); 465var conversion = GetExplicitUserDefinedConversion(source, destination, isChecked: isChecked, ref useSiteInfo); 479public static Conversion FastClassifyConversion(TypeSymbol source, TypeSymbol target) 484return Conversion.GetTrivialConversion(convKind); 487return Conversion.MakeNullableConversion(convKind, FastClassifyConversion(source.StrippedType(), target.StrippedType())); 490public Conversion ClassifyBuiltInConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 496Conversion fastConversion = FastClassifyConversion(source, destination); 503Conversion conversion = ClassifyImplicitBuiltInConversionSlow(source, destination, ref useSiteInfo); 520public Conversion ClassifyStandardConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 532public Conversion ClassifyStandardConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 560Conversion conversion = ClassifyStandardImplicitConversion(sourceExpression, source, destination, ref useSiteInfo); 571return Conversion.NoConversion; 621private Conversion ClassifyStandardImplicitConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 657Conversion conversion = ClassifyImplicitBuiltInConversionFromExpression(sourceExpression, source, destination, ref useSiteInfo); 670return Conversion.NoConversion; 673private Conversion ClassifyStandardImplicitConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 675var conversion = classifyConversion(source, destination, ref useSiteInfo); 679Conversion classifyConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 686return Conversion.Identity; 691return Conversion.ImplicitNumeric; 694var nullableConversion = ClassifyImplicitNullableConversion(source, destination, ref useSiteInfo); 703return Conversion.NoConversion; 708return Conversion.ImplicitReference; 713return Conversion.Boxing; 718return Conversion.PointerToVoid; 723return Conversion.ImplicitPointer; 726var tupleConversion = ClassifyImplicitTupleConversion(source, destination, ref useSiteInfo); 732return Conversion.NoConversion; 736private Conversion ClassifyImplicitBuiltInConversionSlow(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 743return Conversion.NoConversion; 746Conversion conversion = ClassifyStandardImplicitConversion(source, destination, ref useSiteInfo); 752return Conversion.NoConversion; 755private Conversion GetImplicitUserDefinedConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 761private Conversion GetImplicitUserDefinedConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 766private Conversion ClassifyExplicitBuiltInOnlyConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 773return Conversion.NoConversion; 787return Conversion.IntPtr; 792return Conversion.ExplicitEnumeration; 795var nullableConversion = ClassifyExplicitNullableConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 803return (source.Kind == SymbolKind.DynamicType) ? Conversion.ExplicitDynamic : Conversion.ExplicitReference; 808return Conversion.Unboxing; 811var tupleConversion = ClassifyExplicitTupleConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 819return Conversion.PointerToPointer; 824return Conversion.PointerToInteger; 829return Conversion.IntegerToPointer; 834return Conversion.ExplicitDynamic; 837return Conversion.NoConversion; 840private Conversion GetExplicitUserDefinedConversion(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 846private Conversion GetExplicitUserDefinedConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 851private Conversion DeriveStandardExplicitFromOppositeStandardImplicitConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 853var oppositeConversion = ClassifyStandardImplicitConversion(destination, source, ref useSiteInfo); 854Conversion impliedExplicitConversion; 859impliedExplicitConversion = Conversion.Identity; 862impliedExplicitConversion = Conversion.ExplicitNumeric; 865impliedExplicitConversion = Conversion.ExplicitReference; 868impliedExplicitConversion = Conversion.Unboxing; 871impliedExplicitConversion = Conversion.NoConversion; 874impliedExplicitConversion = Conversion.PointerToPointer; 880impliedExplicitConversion = Conversion.NoConversion; 886var underlyingConversion = DeriveStandardExplicitFromOppositeStandardImplicitConversion(strippedSource, strippedDestination, ref useSiteInfo); 891Conversion.MakeNullableConversion(ConversionKind.ExplicitNullable, underlyingConversion) : 892Conversion.NoConversion; 974private static bool ExplicitConversionMayDifferFromImplicit(Conversion implicitConversion) 992private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpression sourceExpression, TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1001return Conversion.ImplicitDynamic; 1008return Conversion.NoConversion; 1013return Conversion.ImplicitEnumeration; 1016var constantConversion = ClassifyImplicitConstantExpressionConversion(sourceExpression, destination); 1025var nullLiteralConversion = ClassifyNullLiteralConversion(sourceExpression, destination); 1033return Conversion.DefaultLiteral; 1038var innerConversion = ClassifyImplicitBuiltInConversionFromExpression(innerExpression, innerExpression.Type, destination, ref useSiteInfo); 1046var tupleConversion = ClassifyImplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, ref useSiteInfo); 1056return Conversion.AnonymousFunction; 1061Conversion methodGroupConversion = GetMethodGroupDelegateConversion((BoundMethodGroup)sourceExpression, destination, ref useSiteInfo); 1070Conversion interpolatedStringConversion = GetInterpolatedStringConversion(sourceExpression, destination, ref useSiteInfo); 1077var stackAllocConversion = GetStackAllocConversion((BoundStackAllocArrayCreation)sourceExpression, destination, ref useSiteInfo); 1085var addressOfConversion = GetMethodGroupFunctionPointerConversion(((BoundUnconvertedAddressOfOperator)sourceExpression).Operand, funcPtrType, ref useSiteInfo); 1093return Conversion.ImplicitThrow; 1096return Conversion.ObjectCreation; 1099return Conversion.NoConversion; 1102private Conversion GetSwitchExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1110return Conversion.NoConversion; 1112var innerConversions = ArrayBuilder<Conversion>.GetInstance(switchExpression.SwitchArms.Length); 1115var nestedConversion = this.ClassifyImplicitConversionFromExpression(arm.Value, destination, ref useSiteInfo); 1119return Conversion.NoConversion; 1125return Conversion.MakeSwitchExpression(innerConversions.ToImmutableAndFree()); 1127return Conversion.NoConversion; 1131private Conversion GetConditionalExpressionConversion(BoundExpression source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1136return Conversion.NoConversion; 1138var trueConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Consequence, destination, ref useSiteInfo); 1140return Conversion.NoConversion; 1142var falseConversion = this.ClassifyImplicitConversionFromExpression(conditionalOperator.Alternative, destination, ref useSiteInfo); 1144return Conversion.NoConversion; 1146return Conversion.MakeConditionalExpression(ImmutableArray.Create(trueConversion, falseConversion)); 1149private static Conversion ClassifyNullLiteralConversion(BoundExpression source, TypeSymbol destination) 1156return Conversion.NoConversion; 1164return Conversion.NullLiteral; 1174return Conversion.ImplicitReference; 1182return Conversion.NullToPointer; 1185return Conversion.NoConversion; 1188private static Conversion ClassifyImplicitConstantExpressionConversion(BoundExpression source, TypeSymbol destination) 1192return Conversion.ImplicitConstant; 1205return new Conversion(ConversionKind.ImplicitNullable, Conversion.ImplicitConstantUnderlying); 1209return Conversion.NoConversion; 1212private Conversion ClassifyImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1216var tupleConversion = GetImplicitTupleLiteralConversion(source, destination, ref useSiteInfo); 1231var underlyingTupleConversion = GetImplicitTupleLiteralConversion(source, nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, ref useSiteInfo); 1240return Conversion.NoConversion; 1243private Conversion ClassifyExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1247var tupleConversion = GetExplicitTupleLiteralConversion(source, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1262var underlyingTupleConversion = GetExplicitTupleLiteralConversion(source, nt.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type, isChecked: isChecked, ref useSiteInfo, forCast); 1271return Conversion.NoConversion; 1326private Conversion ClassifyExplicitOnlyConversionFromExpression(BoundExpression sourceExpression, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 1337Conversion tupleConversion = ClassifyExplicitTupleLiteralConversion((BoundTupleLiteral)sourceExpression, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1348Conversion fastConversion = FastClassifyConversion(sourceType, destination); 1355var conversion = ClassifyExplicitBuiltInOnlyConversion(sourceType, destination, isChecked: isChecked, ref useSiteInfo, forCast); 1579internal Conversion ClassifyImplicitUserDefinedConversionForV6SwitchGoverningType(TypeSymbol sourceType, out TypeSymbol switchGoverningType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1611internal Conversion GetCallerLineNumberConversion(TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1624return Conversion.ImplicitEnumeration; 1627var constantConversion = ClassifyImplicitConstantExpressionConversion(intMaxValueLiteral, destination); 1644Conversion conversion = ClassifyStandardImplicitConversion(expectedAttributeType, destination, ref useSiteInfo); 1770public Conversion ConvertExtensionMethodThisArg(TypeSymbol parameterType, TypeSymbol thisType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1773var conversion = this.ClassifyImplicitExtensionMethodThisArgConversion(sourceExpressionOpt: null, thisType, parameterType, ref useSiteInfo); 1774return IsValidExtensionMethodThisArgConversion(conversion) ? conversion : Conversion.NoConversion; 1779public Conversion ClassifyImplicitExtensionMethodThisArgConversion(BoundExpression sourceExpressionOpt, TypeSymbol sourceType, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 1789return Conversion.Identity; 1794return Conversion.Boxing; 1799return Conversion.ImplicitReference; 1808var tupleConversion = GetTupleLiteralConversion( 1825var tupleConversion = ClassifyTupleConversion( 1834return Conversion.NoConversion; 1846return Conversion.NoConversion; 1855public static bool IsValidExtensionMethodThisArgConversion(Conversion conversion) 1867foreach (var elementConversion in conversion.UnderlyingConversions) 2089private Conversion ClassifyImplicitNullableConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2102return Conversion.NoConversion; 2110return Conversion.NoConversion; 2115return new Conversion(ConversionKind.ImplicitNullable, Conversion.IdentityUnderlying); 2120return new Conversion(ConversionKind.ImplicitNullable, Conversion.ImplicitNumericUnderlying); 2123var tupleConversion = ClassifyImplicitTupleConversion(unwrappedSource, unwrappedDestination, ref useSiteInfo); 2129return Conversion.NoConversion; 2132private delegate Conversion ClassifyConversionFromExpressionDelegate(ConversionsBase conversions, BoundExpression sourceExpression, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2133private delegate Conversion ClassifyConversionFromTypeDelegate(ConversionsBase conversions, TypeWithAnnotations source, TypeWithAnnotations destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast); 2135private Conversion GetImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2153private Conversion GetExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2171private Conversion GetTupleLiteralConversion( 2187return Conversion.NoConversion; 2194var argumentConversions = ArrayBuilder<Conversion>.GetInstance(arguments.Length); 2198var result = classifyConversion(this, argument, targetElementTypes[i], isChecked: isChecked, ref useSiteInfo, forCast: forCast); 2202return Conversion.NoConversion; 2211private Conversion ClassifyImplicitTupleConversion(TypeSymbol source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2222return Conversion.NoConversion; 2230private Conversion ClassifyExplicitTupleConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2241return Conversion.NoConversion; 2249private Conversion ClassifyTupleConversion( 2265return Conversion.NoConversion; 2268var nestedConversions = ArrayBuilder<Conversion>.GetInstance(sourceTypes.Length); 2271var conversion = classifyConversion(this, sourceTypes[i], destTypes[i], isChecked: isChecked, ref useSiteInfo, forCast); 2275return Conversion.NoConversion; 2284private Conversion ClassifyExplicitNullableConversion(TypeSymbol source, TypeSymbol destination, bool isChecked, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, bool forCast) 2299return Conversion.NoConversion; 2307return new Conversion(ConversionKind.ExplicitNullable, Conversion.IdentityUnderlying); 2312return new Conversion(ConversionKind.ExplicitNullable, Conversion.ImplicitNumericUnderlying); 2317return new Conversion(ConversionKind.ExplicitNullable, Conversion.ExplicitNumericUnderlying); 2320var tupleConversion = ClassifyExplicitTupleConversion(unwrappedSource, unwrappedDestination, isChecked: isChecked, ref useSiteInfo, forCast); 2328return new Conversion(ConversionKind.ExplicitNullable, Conversion.ExplicitEnumerationUnderlying); 2333return new Conversion(ConversionKind.ExplicitNullable, Conversion.PointerToIntegerUnderlying); 2336return Conversion.NoConversion;

38public override Conversion GetMethodGroupDelegateConversion(BoundMethodGroup source, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 44public override Conversion GetMethodGroupFunctionPointerConversion(BoundMethodGroup source, FunctionPointerTypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 50public override Conversion GetStackAllocConversion(BoundStackAllocArrayCreation sourceExpression, TypeSymbol destination, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 56protected override Conversion GetInterpolatedStringConversion(BoundExpression 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,

264Conversion fromConversion = EncompassingExplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo); 265Conversion toConversion = EncompassingExplicitConversion(convertsTo, target, ref useSiteInfo); 316Conversion liftedFromConversion = EncompassingExplicitConversion(sourceExpression, source, nullableFrom, ref useSiteInfo); 317Conversion liftedToConversion = EncompassingExplicitConversion(nullableTo, target, ref useSiteInfo); 470private Conversion EncompassingExplicitConversion(BoundExpression expr, TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 489var result = ClassifyStandardConversion(expr, a, b, ref useSiteInfo); 490return result.IsEnumeration ? Conversion.NoConversion : result; 493private Conversion EncompassingExplicitConversion(TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

294Conversion fromConversion = EncompassingImplicitConversion(sourceExpression, source, convertsFrom, ref useSiteInfo); 295Conversion toConversion = allowAnyTarget ? Conversion.Identity : 316toConversion = allowAnyTarget ? Conversion.Identity : 342Conversion liftedFromConversion = EncompassingImplicitConversion(sourceExpression, source, nullableFrom, ref useSiteInfo); 343Conversion liftedToConversion = !allowAnyTarget ? 345Conversion.Identity; 584private Conversion EncompassingImplicitConversion(BoundExpression aExpr, TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 595var result = ClassifyStandardImplicitConversion(aExpr, a, b, ref useSiteInfo); 596return IsEncompassingImplicitConversionKind(result.Kind) ? result : Conversion.NoConversion; 599private Conversion EncompassingImplicitConversion(TypeSymbol a, TypeSymbol b, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)

15public readonly Conversion LeftConversion; 16public readonly Conversion RightConversion; 20private BinaryOperatorAnalysisResult(OperatorAnalysisResultKind kind, BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion) 50public static BinaryOperatorAnalysisResult Applicable(BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion) 55public static BinaryOperatorAnalysisResult Inapplicable(BinaryOperatorSignature signature, Conversion leftConversion, Conversion rightConversion)

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

777var convLeft = Conversions.ClassifyConversionFromExpression(left, op.LeftType, isChecked: isChecked, ref useSiteInfo); 778var convRight = Conversions.ClassifyConversionFromExpression(right, op.RightType, isChecked: isChecked, ref useSiteInfo);

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

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

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

19public readonly ImmutableArray<Conversion> ConversionsOpt; 37ImmutableArray<Conversion> conversionsOpt = default, 61public Conversion ConversionForArg(int arg) 65return Conversion.Identity; 221public static MemberAnalysisResult BadArgumentConversions(ImmutableArray<int> argsToParamsOpt, ImmutableArray<int> badArguments, ImmutableArray<Conversion> conversions) 274public static MemberAnalysisResult NormalForm(ImmutableArray<int> argsToParamsOpt, ImmutableArray<Conversion> conversions, bool hasAnyRefOmittedArgument) 279public static MemberAnalysisResult ExpandedForm(ImmutableArray<int> argsToParamsOpt, ImmutableArray<Conversion> conversions, bool hasAnyRefOmittedArgument)

2158var c1 = m1.Result.ConversionForArg(i); 2159var c2 = m2.Result.ConversionForArg(i); 2371Conversion conv1, 2374Conversion conv2, 2424private BetterResult BetterConversionFromExpression(BoundExpression node, TypeSymbol t1, Conversion conv1, TypeSymbol t2, Conversion conv2, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo, out bool okToDowngradeToNeither) 2707return BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out okToDowngradeToNeither, BetterConversionTargetRecursionLimit); 2723return BetterConversionTargetCore(null, type1, default(Conversion), type2, default(Conversion), ref useSiteInfo, out okToDowngradeToNeither, betterConversionTargetRecursionLimit - 1); 2729Conversion conv1, 2731Conversion conv2, 2741Conversion conv1, 2743Conversion conv2, 2896private bool IsMethodGroupConversionIncompatibleWithDelegate(BoundMethodGroup node, NamedTypeSymbol delegateType, Conversion conv) 3638ArrayBuilder<Conversion> conversions = null; 3643Conversion conversion; 3650conversion = Conversion.Identity; 3656conversion = Conversion.NoConversion; 3726conversions = ArrayBuilder<Conversion>.GetInstance(paramCount); 3727conversions.AddMany(Conversion.Identity, argumentPosition); 3738var conversionsArray = conversions != null ? conversions.ToImmutableAndFree() : default(ImmutableArray<Conversion>); 3751private Conversion CheckArgumentForApplicability( 3775return Conversion.NoConversion; 3787return Conversion.ImplicitDynamic; 3798return Conversion.Identity; 3803var conversion = forExtensionMethodThisArg ? 3812return Conversion.NoConversion; 3820return Conversion.Identity; 3824return Conversion.NoConversion;

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

190Conversion iDisposableConversion = classifyConversion(fromExpression, disposableInterface, ref useSiteInfo); 256Conversion alternateConversion = classifyConversion(fromExpression, alternateInterface, ref discardedUseSiteInfo); 269Conversion classifyConversion(bool fromExpression, TypeSymbol targetInterface, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 275var result = conversions.ClassifyImplicitConversionFromExpression(expressionOpt, targetInterface, ref useSiteInfo); 283var result = conversions.ClassifyImplicitConversionFromType(declarationTypeOpt, targetInterface, ref useSiteInfo);

222public static Conversion GetConversion(this BoundExpression boundNode) 231return Conversion.Identity;

388public static Conversion GetConversion(BoundExpression? conversion, BoundValuePlaceholder? placeholder) 393return Conversion.NoConversion; 422return Conversion.Identity;

271public static BoundConversion SynthesizedNonUserDefined(SyntaxNode syntax, BoundExpression operand, Conversion conversion, TypeSymbol type, ConstantValue? constantValueOpt = null) 295Conversion conversion, 321Conversion conversion, 345Conversion conversion, 358Conversion conversion,

18internal ConversionGroup(Conversion conversion, TypeWithAnnotations explicitType = default) 33internal readonly Conversion Conversion;

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

2111/// <returns>A <see cref="Conversion"/> that classifies the conversion from the 2113public Conversion ClassifyConversion(ITypeSymbol source, ITypeSymbol destination) 2159return Conversion.NoConversion; 2170return Conversion.NullLiteral; 2173return Conversion.NoConversion; 2176Conversion result = ClassifyConversion(sourceType, destination);

966return new CSharpTypeInfo(declarationTypeSymbol, declarationTypeSymbol, nullabilityInfo, nullabilityInfo, Conversion.Identity); 970return new CSharpTypeInfo(declarationInfo.Type, declarationInfo.Type, declarationInfo.Nullability, declarationInfo.Nullability, Conversion.Identity); 1008public Conversion GetConversion(SyntaxNode expression, CancellationToken cancellationToken = default(CancellationToken)) 1069public Conversion GetSpeculativeConversion(int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption) 2052return new CSharpTypeInfo(member.Type, member.Type, nullability: default, convertedNullability: default, Conversion.Identity); 2109Conversion conversion; 2158conversion = convertedSwitchConversion.IsValid ? convertedSwitchConversion : Conversion.NoConversion; 2165conversion = Conversion.Identity; 2176conversion = Conversion.MakeConditionalExpression(ImmutableArray<Conversion>.Empty); 2183conversion = Conversion.Identity; 2191conversion = Conversion.Identity; 2236conversion = Conversion.Identity; 2255conversion = Conversion.Identity; 2353return new CSharpTypeInfo(type, type, default, default, Conversion.Identity); 2801public abstract Conversion ClassifyConversion(ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false); 2819public Conversion ClassifyConversion(int position, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 2831return Conversion.NoConversion; 2857return Conversion.NoConversion; 2872internal abstract Conversion ClassifyConversionForCast(ExpressionSyntax expression, TypeSymbol destination); 2888internal Conversion ClassifyConversionForCast(int position, ExpressionSyntax expression, TypeSymbol destination) 2909return Conversion.NoConversion;

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

55public Conversion ElementConversion { get; } 60public Conversion CurrentConversion { get; } 71Conversion elementConversion, 72Conversion currentConversion)

419public override Conversion ClassifyConversion( 434return Conversion.NoConversion; 468return Conversion.NoConversion; 476internal override Conversion ClassifyConversionForCast( 492return Conversion.NoConversion;

216public override Conversion ClassifyConversion( 224internal override Conversion ClassifyConversionForCast(

516public override Conversion ClassifyConversion(ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 523return Conversion.NoConversion; 548return Conversion.NoConversion; 554internal override Conversion ClassifyConversionForCast(ExpressionSyntax expression, TypeSymbol destination) 569return 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)

273Conversion.ImplicitReference);

127Conversion.ExplicitReference, 156Conversion.ExplicitReference, 399conversion: Conversion.ExplicitReference, 463conversion: 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; 855public static Conversion GetSpeculativeConversion(this SemanticModel? semanticModel, int position, ExpressionSyntax expression, SpeculativeBindingOption bindingOption) 864return Conversion.NoConversion; 1283public static Conversion ClassifyConversion(this SemanticModel? semanticModel, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 1294return Conversion.NoConversion; 1303public static Conversion ClassifyConversion(this SemanticModel? semanticModel, int position, ExpressionSyntax expression, ITypeSymbol destination, bool isExplicitInSource = false) 1312return Conversion.NoConversion;

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

224/// The delegate is invoked by <see cref="VisitConversion(BoundConversion, BoundExpression, Conversion, TypeWithAnnotations, TypeWithState, bool, bool, bool, AssignmentKind, ParameterSymbol, bool, bool, bool, Optional&lt;LocalState&gt;,bool, Location, ArrayBuilder&lt;VisitResult&gt;)"/>. 4186var conversions = ArrayBuilder<Conversion>.GetInstance(n); 4192(BoundExpression expressionNoConversion, Conversion conversion) = RemoveConversion(expression, includeExplicitConversions: false); 4236_ = VisitConversion(conversionOpt: null, conversionOperand: expressionsNoConversions[i], Conversion.Identity, targetTypeWithNullability: inferredType, operandType: expressionTypes[i], 4339Conversion conversion = conversionsWithoutNullability.ClassifyConversionFromExpression(placeholder, bestType, isChecked: returns[i].isChecked, ref discardedUseSiteInfo); 4511leftConversion = Conversion.Identity; 4531leftConversion = Conversion.Identity; 4633Conversion leftConversion, 4636Conversion rightConversion, 4667Conversion conversion, 4704Conversion conversion, 4751var conversion = _conversions.ClassifyBuiltInConversion(derivedType, baseType, isChecked: false, ref discardedUseSiteInfo); 4762Conversion leftConversion, 5191var conversion = GenerateConversionForConditionalOperator(node.LeftOperand, leftType, rightType, reportMismatch: true, isChecked: node.Checked); 5451(var consequence, var consequenceConversion, consequenceRValue) = visitConditionalOperand(consequenceState, originalConsequence); 5456(var alternative, var alternativeConversion, alternativeRValue) = visitConditionalOperand(alternativeState, originalAlternative); 5519TypeWithState consequenceRValue, TypeWithState alternativeRValue, BoundExpression consequence, Conversion consequenceConversion, bool consequenceEndReachable, 5520BoundExpression alternative, Conversion alternativeConversion, bool alternativeEndReachable, TypeWithAnnotations resultTypeWithAnnotations, bool wasTargetTyped) 5570Conversion consequenceConversion, 5573Conversion alternativeConversion, 5586(BoundExpression, Conversion, TypeWithState) visitConditionalOperand(LocalState state, BoundExpression operand) 5588Conversion conversion; 5611Conversion conversion, 6170(ImmutableArray<BoundExpression> argumentsNoConversions, ImmutableArray<Conversion> conversions) = RemoveArgumentConversions(arguments, refKindsOpt); 6185ImmutableArray<Conversion> conversions, 6258conversions.IsDefault || i >= conversions.Length ? Conversion.Identity : conversions[i], 6341ImmutableArray<Conversion> conversions, 6551Conversion conversion, 6940private (ImmutableArray<BoundExpression> arguments, ImmutableArray<Conversion> conversions) RemoveArgumentConversions( 6945var conversions = default(ImmutableArray<Conversion>); 6949var conversionsBuilder = ArrayBuilder<Conversion>.GetInstance(n); 6955var conversion = Conversion.Identity; 7209private static (BoundExpression expression, Conversion conversion) RemoveConversion(BoundExpression expr, bool includeExplicitConversions) 7228return (expr, Conversion.Identity); 7243return (expr, group?.Conversion ?? Conversion.Identity); 7247private Conversion GenerateConversionForConditionalOperator(BoundExpression sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool reportMismatch, bool isChecked) 7249var conversion = GenerateConversion(_conversions, sourceExpression, sourceType, destinationType, fromExplicitCast: false, extensionMethodThisArgument: false, isChecked: isChecked); 7258private static Conversion GenerateConversion(Conversions conversions, BoundExpression? sourceExpression, TypeSymbol? sourceType, TypeSymbol destinationType, bool fromExplicitCast, bool extensionMethodThisArgument, bool isChecked) 7432(BoundExpression operand, Conversion conversion) = RemoveConversion(node, includeExplicitConversions: true); 7479(BoundExpression operand, Conversion conversion) = RemoveConversion(expr, includeExplicitConversions: false); 7490Conversion conversion, TypeWithState operandType, 7522Func<TypeWithAnnotations, TypeWithState> visitConversionAsContinuation(BoundExpression expr, bool useLegacyWarnings, bool trackMembers, AssignmentKind assignmentKind, BoundExpression operand, Conversion conversion, TypeWithState operandType) 7669Conversion conversion, 7697void trackConvertedValue(FieldSymbol targetField, Conversion conversion, FieldSymbol valueField) 7910Conversion conversion, 7941conversion = Conversion.MakeNullableConversion(ConversionKind.ImplicitNullable, Conversion.Identity); 8436Conversion conversion, 8664var conversion = _conversions.ClassifyStandardConversion(operandType.Type, targetType.Type, ref discardedUseSiteInfo); 8938CheckExtensionMethodThisNullability(receiverOpt, Conversion.Identity, method.Parameters[0], receiverType); 9247private void VisitDeconstructionArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt = null) 9261private void VisitDeconstructMethodArguments(ArrayBuilder<DeconstructionVariable> variables, Conversion conversion, BoundExpression right, TypeWithState? rightResultOpt) 9319var argConversion = RemoveConversion(invocation.Arguments[0], includeExplicitConversions: false).conversion; 9328var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 9369var underlyingConversion = BoundNode.GetConversion(placeholderConversion, placeholder); 10205Conversion conversion = BoundNode.GetConversion(node.ElementConversion, node.ElementPlaceholder); 10918private void CheckExtensionMethodThisNullability(BoundExpression expr, Conversion conversion, ParameterSymbol parameter, TypeWithState result)

873var conversions = ArrayBuilder<Conversion>.GetInstance(numSwitchArms); 891(BoundExpression expression, Conversion conversion) = RemoveConversion(arm.Value, includeExplicitConversions: false); 943ArrayBuilder<Conversion> conversions, 988ArrayBuilder<Conversion> conversions,

2840public BoundConversion(SyntaxNode syntax, BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, ImmutableArray<MethodSymbol> originalUserDefinedConversionsOpt, TypeSymbol type, bool hasErrors = false) 2859public Conversion Conversion { get; } 2870public BoundConversion Update(BoundExpression operand, Conversion conversion, bool isBaseConversion, bool @checked, bool explicitCastInCode, ConstantValue? constantValueOpt, ConversionGroup? conversionGroupOpt, ImmutableArray<MethodSymbol> originalUserDefinedConversionsOpt, TypeSymbol type)

563F.Convert(notifyCompletionTemp.Type, F.Local(awaiterTemp), Conversion.ExplicitReference)),

810private BoundExpression MakeConversionLambda(Conversion conversion, TypeSymbol fromType, TypeSymbol toType)

212void visitConversion(Conversion conversion) 226foreach (var underlying in conversion.UnderlyingConversions)

211Conversion conversion = _factory.Compilation.Conversions.ClassifyBuiltInConversion(inputType, output.Type, isChecked: false, ref useSiteInfo); 484_factory.Compilation.Conversions.ClassifyBuiltInConversion(test.Input.Type, typeEvaluation2.Type, isChecked: false, ref useSiteInfo) is Conversion conv &&

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

736var conversion = _compilation.Conversions.ClassifyConversionFromExpression(loweredLeft, boolean, isChecked: false, ref useSiteInfo); 1953MakeConversionNode(syntax, call, Conversion.ExplicitReference, type, @checked: false) : 2024rewrittenExpr = MakeConversionNode(syntax, rewrittenExpr, Conversion.Boxing, objectType, @checked: false); 2290: _factory.Convert(_factory.SpecialType(destinationType), numericOperand, Conversion.IntegerToPointer); 2307numericOperand = _factory.Convert(nativeIntType, numericOperand, Conversion.IntegerToPointer, isChecked); 2319numericOperand = _factory.Convert(longType, numericOperand, Conversion.ExplicitNumeric, isChecked); 2320sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2332sizeOfExpression = _factory.Convert(longType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2344sizeOfExpression = _factory.Convert(ulongType, sizeOfExpression, Conversion.ExplicitNumeric, isChecked); 2363: _factory.Convert(convertedMultiplicationResultType, multiplication, Conversion.IntegerToPointer); // NOTE: for some reason, dev10 doesn't check this conversion. 2393Conversion.PointerToInteger);

758Conversion.Boxing,

259Conversion conversion, 278Conversion.Identity, 294Conversion conversion, 413conversion = Conversion.ExplicitNumeric; 464var outerConversion = new Conversion(ConversionKind.ImplicitNullable, Conversion.IdentityUnderlying); 647Conversion conversion = MakeConversion(rewrittenOperand, rewrittenType, @checked: @checked, _compilation, _diagnostics, acceptFailingConversion); 663private static Conversion MakeConversion( 673Conversion conversion = compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: @checked, ref useSiteInfo); 697Conversion conversion, 807Conversion conversion, 894Conversion conversion, 950Conversion conversion, 977rewrittenOperand = BoundConversion.SynthesizedNonUserDefined(syntax, rewrittenOperand, Conversion.ImplicitEnumeration, rewrittenOperandType); 1002Conversion conversion, 1064Conversion conversion, 1091Conversion conversion, 1131Conversion conversion, 1193Conversion conversion, 1242Conversion conversion, 1249Conversion conv = TryMakeConversion(syntax, conversion, rewrittenOperand.Type, rewrittenType, @checked: @checked); 1325Conversion conversion, 1585var conversion = new Conversion(conversionKind, method, isExtensionMethod: false); 1599private Conversion TryMakeConversion(SyntaxNode syntax, Conversion conversion, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1609Conversion fromConversion = TryMakeConversion(syntax, conversion.UserDefinedFromConversion, fromType, meth.Parameters[0].Type, @checked: @checked); 1612return Conversion.NoConversion; 1615Conversion toConversion = TryMakeConversion(syntax, conversion.UserDefinedToConversion, meth.ReturnType, toType, @checked: @checked); 1618return Conversion.NoConversion; 1630var resultConversion = new Conversion(result, conversion.IsImplicit); 1642return Conversion.NoConversion; 1656return Conversion.NoConversion; 1673return Conversion.NoConversion; 1686return Conversion.NoConversion; 1700private Conversion TryMakeConversion(SyntaxNode syntax, TypeSymbol fromType, TypeSymbol toType, bool @checked) 1703var result = TryMakeConversion(syntax, _compilation.Conversions.ClassifyConversionFromType(fromType, toType, isChecked: @checked, ref useSiteInfo), fromType, toType, @checked: @checked); 1711private Conversion TryMakeUserDefinedConversion(SyntaxNode syntax, MethodSymbol meth, TypeSymbol fromType, TypeSymbol toType, bool @checked, bool isImplicit) 1715Conversion fromConversion = TryMakeConversion(syntax, fromType, meth.Parameters[0].Type, @checked: @checked); 1718return Conversion.NoConversion; 1721Conversion toConversion = TryMakeConversion(syntax, meth.ReturnType, toType, @checked: @checked); 1724return 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,

433Conversion.PinnedObjectToPointer);

113BoundExpression collectionExpression = GetUnconvertedCollectionExpression(node, out Conversion collectionConversion); 289Conversion receiverConversion = enumeratorType.IsStructType() ? 290Conversion.Boxing : 291Conversion.ImplicitReference; 448private BoundExpression ConvertReceiverForInvocation(CSharpSyntaxNode syntax, BoundExpression receiver, MethodSymbol method, Conversion receiverConversion, TypeSymbol convertedReceiverType) 1000private static BoundExpression GetUnconvertedCollectionExpression(BoundForEachStatement node, out Conversion collectionConversion)

49Conversion.Boxing,

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

49Conversion conversion = _compilation.Conversions.ClassifyConversionFromType(rewrittenOperand.Type, rewrittenType, isChecked: false, ref useSiteInfo);

151Conversion c = _localRewriter._compilation.Conversions.ClassifyConversionFromExpression(expression, type, isChecked: false, ref discardedUseSiteInfo);

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

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

170Conversion.ImplicitDynamic, 246Conversion.ImplicitDynamic,

288var conversion = node.Conversion;

524var conversion = Compilation.Conversions.ClassifyConversionFromType(expression.Type, CurrentFunction.ReturnType, isChecked: false, ref useSiteInfo); 612Conversion c = Compilation.Conversions.ClassifyBuiltInConversion(operand.Type, type, isChecked: false, ref discardedUseSiteInfo); 1171? BoundConversion.SynthesizedNonUserDefined(syntax, nullLiteral, Conversion.NullToPointer, type) 1360Conversion c = Compilation.Conversions.ClassifyConversionFromExpression(arg, type, isChecked: false, ref useSiteInfo); 1368public BoundExpression Convert(TypeSymbol type, BoundExpression arg, Conversion conversion, bool isChecked = false) 1652rewrittenExpr = Convert(objectType, rewrittenExpr, Conversion.Boxing);

1072Conversion conversion = boundConversion.Conversion; 1137Conversion conversion = BoundNode.GetConversion(boundAsOperator.OperandConversion, boundAsOperator.OperandPlaceholder); 1293Conversion inConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.LeftConversion, boundCompoundAssignmentOperator.LeftPlaceholder); 1294Conversion outConversion = BoundNode.GetConversion(boundCompoundAssignmentOperator.FinalConversion, boundCompoundAssignmentOperator.FinalPlaceholder); 1526Conversion valueConversion = BoundNode.GetConversion(boundNullCoalescingOperator.LeftConversion, boundNullCoalescingOperator.LeftPlaceholder); 1531valueConversion = Conversion.Identity;

52var conversion = conversions.ConvertExtensionMethodThisArg(method.Parameters[0].Type, receiverType, ref useSiteInfo);

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

225var conversion = conversionOperation.GetConversion(); 278var originalConversion = originalConversionOperation.GetConversion(); 536var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 591var innerOriginalConversion = originalConversionOperation.GetConversion(); 602var outerOriginalConversion = outerOriginalConversionOperation.GetConversion(); 629var originalConversion = originalConversionOperation.GetConversion(); 655var rewrittenBitwiseNotConversion = rewrittenBitwiseNotConversionOperation.GetConversion(); 697var originalConversion = conversionOperation.GetConversion(); 837Conversion conversion, 896var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 924var parentConversion = semanticModel.GetConversion(castNode, cancellationToken); 972var conversion = semanticModel.GetConversion(current, cancellationToken); 1054var oldConversion = oldForEachInfo.ElementConversion; 1055var newConversion = newForEachInfo.ElementConversion; 1312private static (ITypeSymbol? rewrittenConvertedType, Conversion rewrittenConversion) GetRewrittenInfo( 1315Conversion originalConversion, ITypeSymbol originalConvertedType, 1331var rewrittenConversion = rewrittenSemanticModel.GetConversion(rewrittenExpression, cancellationToken);

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

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

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

106var initializerConversion = semanticModel.GetConversion(initializerValue, cancellationToken); 125var elementConversion = semanticModel.GetForEachStatementInfo(forEachStatement).ElementConversion; 137Conversion conversion,

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

37Conversion> 396var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalOtherPartOfConditional, originalExpressionType); 397var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newOtherPartOfConditional, newExpressionType); 431var originalConversion = this.OriginalSemanticModel.ClassifyConversion(oldSwitchStatement.Expression, originalCaseType); 432var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newSwitchStatement.Expression, newCaseType); 534var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType); 535var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType); 693var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalIsOrAsExpression.Left, originalConvertedType, isExplicitInSource: true); 694var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newIsOrAsExpression.Left, newConvertedType, isExplicitInSource: true); 742var originalConversion = originalModel.GetConversion(originalExpression); 743var newConversion = newModel.GetConversion(newExpression); 780private bool ConversionsAreCompatible(Conversion originalConversion, Conversion newConversion) 822protected override Conversion ClassifyConversion(SemanticModel model, ExpressionSyntax expression, ITypeSymbol targetType) 825protected override Conversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType)

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

399var conv = model.GetConversion(expr);

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

10762var conversion = model.GetConversion(lambdas[0]); 10767Assert.Equal(Conversion.NoConversion, conversion);

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

7506var castConversion = model.GetConversion(value); 7510var tupleConversion = model.GetConversion(tuple); 7539var tupleConversion = model.GetConversion(value); 7581var conversion1 = model.GetConversion(tuple1); 7590var conversion2 = model.GetConversion(tuple2); 7599var conversion3 = model.GetConversion(tuple3); 7647var conversion = model.GetConversion(tuple); 8335Assert.Equal(Conversion.Identity, model.GetConversion(l11)); 8360Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8502Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8536Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8609Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8638Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8673Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8702Assert.Equal(Conversion.Identity, model.GetConversion(node)); 8762Assert.Equal(Conversion.Identity, model.GetConversion(l11)); 8787Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8847Assert.Equal(Conversion.Identity, model.GetConversion(lnull)); 8860Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 8970Assert.Equal(Conversion.Identity, model.GetConversion(node.Parent)); 9083Assert.Equal(Conversion.NoConversion, model.GetConversion(node)); 17223Assert.Equal(Conversion.Identity, model.GetConversion(n1)); 17230Assert.Equal(Conversion.Identity, model.GetConversion(n2)); 17237Assert.Equal(Conversion.Identity, model.GetConversion(n3)); 17244Assert.Equal(Conversion.Identity, model.GetConversion(n4)); 17305Assert.Equal(Conversion.ImplicitReference, model.GetConversion(n4));

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

2892var conversion = model.GetConversion(expr);

93var conversion = _conversions.ClassifyImplicitConversionFromExpression(rewrittenThis, baseType, ref discardedSiteInfo);

193var conversion = compilation.Conversions.ClassifyConversionFromExpression(expr, type, isChecked: false, ref useSiteInfo);

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

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

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

106var initializerConversion = semanticModel.GetConversion(initializerValue, cancellationToken); 125var elementConversion = semanticModel.GetForEachStatementInfo(forEachStatement).ElementConversion; 137Conversion conversion,

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

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

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

48Assert.Equal(Conversion.Identity, compoundAssignment.GetInConversion()); 49Assert.Equal(Conversion.Identity, compoundAssignment.GetOutConversion()); 88var inConversion = new Conversion(ConversionKind.ImplicitUserDefined, inSymbol, false); 89var outConversion = new Conversion(ConversionKind.ImplicitUserDefined, outSymbol, false);

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

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

1223private static Conversion GetCollectionConversion(BoundForEachStatement boundNode) 2146var conv = model.GetConversion(loopSyntax.Type);

191var conversion = model.GetConversion(initializer1); 196var classifiedConversion = comp.ClassifyConversion(typeInfo.Type, typeInfo.ConvertedType!); 273var conversion = model.GetConversion(literal); 281var classifiedConversion = model.ClassifyConversion(literal, typeInfo.ConvertedType); 333var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 341var underlying = conversion.UnderlyingConversions.Single(); 384var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 436var conversion = model.ClassifyConversion(conversions[0].Expression, typeInfoOuter.Type!); 486var conversion = model.ClassifyConversion(conv.Expression, typeInfoOuter.Type!); 583var conversion = model.GetConversion(decl); 587var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 822var conversion = model.GetConversion(decl); 828var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!); 880var conversion = model.GetConversion(initializer); 887var classifiedConversion = comp.ClassifyConversion(typeInfo.Type!, typeInfo.ConvertedType!);

841var conv = model.GetConversion(expr);

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

813var conversion = compilation.Conversions.ClassifyConversionFromExpression(

3253"valuePlaceholder" => Conversion.Identity, 3256Conversion.NoConversion

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

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); 2352Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2358Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2364Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2370Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2380Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2386Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2392Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2398Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2408Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2414Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2420Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2426Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2458Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2464Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2470Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2480Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2486Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2492Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2502Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2508Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2514Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2558Assert.Equal(Conversion.NoConversion, stackallocInfo.ImplicitConversion); 2564Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2570Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion); 2576Assert.Equal(Conversion.ImplicitNumeric, sizeInfo.ImplicitConversion); 2586Assert.Equal(Conversion.NoConversion, stackallocInfo.ImplicitConversion); 2592Assert.Equal(Conversion.ImplicitNumeric, element0Info.ImplicitConversion); 2598Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion); 2604Assert.Equal(Conversion.Identity, sizeInfo.ImplicitConversion); 2642Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2648Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 2654Assert.Equal(Conversion.Identity, element1Info.ImplicitConversion); 2664Assert.Equal(Conversion.Identity, stackallocInfo.ImplicitConversion); 2670Assert.Equal(Conversion.Identity, element0Info.ImplicitConversion); 2676Assert.Equal(Conversion.ImplicitNumeric, element1Info.ImplicitConversion);

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

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

4429var conv = model.GetConversion(syntax); 4432Assert.Equal(Conversion.Identity, conv); 4496var conv = model.GetConversion(syntax); 4499Assert.Equal(Conversion.Identity, conv); 4534var conv = model.GetConversion(syntax); 4537Assert.Equal(Conversion.Identity, conv); 4576var conv = model.GetConversion(syntax); 4579Assert.Equal(Conversion.Identity, conv); 4707var conv = model.GetConversion(syntax); 4710Assert.Equal(Conversion.Identity, conv); 5511var conv = model.GetConversion(node); 5556var conv = model.GetConversion(value); 6046Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 6081Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 6508Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 7399Assert.Equal(Conversion.Identity, summary.ImplicitConversion); 7475Assert.Equal(Conversion.PointerToVoid, summary0.ImplicitConversion); 7482Assert.Equal(Conversion.PointerToVoid, summary1.ImplicitConversion); 7488Assert.Equal(Conversion.PointerToVoid, summary2.ImplicitConversion); 7794Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 7806Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 7856Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 7868Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 7916Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 7928Assert.Equal(Conversion.Identity, sizeOfSummary.ImplicitConversion); 8461Assert.Equal(Conversion.PointerToVoid, stackAllocSummary.ImplicitConversion); 8473Assert.Equal(Conversion.Identity, typeSummary.ImplicitConversion); 8485Assert.Equal(Conversion.ImplicitNumeric, countSummary.ImplicitConversion);

42var conv1 = Conversion.Identity; 49var 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); 648var conversion = info.Type != null && info.ConvertedType != null ? model.Compilation.ClassifyConversion(info.Type, info.ConvertedType) : Conversion.NoConversion; 655ValidateConversion(Conversion.PointerToVoid, ConversionKind.ImplicitPointerToVoid); 656ValidateConversion(Conversion.NullToPointer, ConversionKind.ImplicitNullToPointer); 657ValidateConversion(Conversion.PointerToPointer, ConversionKind.ExplicitPointerToPointer); 658ValidateConversion(Conversion.IntegerToPointer, ConversionKind.ExplicitIntegerToPointer); 659ValidateConversion(Conversion.PointerToInteger, ConversionKind.ExplicitPointerToInteger); 660ValidateConversion(Conversion.IntPtr, ConversionKind.IntPtr); 664private void ValidateConversion(Conversion conv, ConversionKind kind) 847var conv = semanticModel.GetConversion(expr); 850Conversion act1 = semanticModel.ClassifyConversion(expr, info.ConvertedType); 863var act2 = semanticModel.Compilation.ClassifyConversion(info.Type, info.ConvertedType); 876Conversion act1 = semanticModel.ClassifyConversion(expr, expsym); 2456var conv = model.GetConversion(expr); 2485var conv = model.GetConversion(expr); 2734var conv = model.GetConversion(expr); 2735Assert.Equal(Conversion.Identity, conv); 2805var conv = model.GetConversion(expr); 3336var conversion = model.ClassifyConversion(expr, gNullableType); 3402var conversion = model.ClassifyConversion(expr, gNullableType); 3477var argConversion = model.GetConversion(argexpr); 3531var argConversion = model.GetConversion(argexpr); 3610var conv = model.GetConversion(literal); 3635var literalConversion = model.GetConversion(literal); 3643var castConversion = model.GetConversion(cast); 3668var literalConversion = model.GetConversion(literal); 3676var castConversion = model.GetConversion(cast); 3704var literalConversion = model.GetConversion(literal); 3712var cast1Conversion = model.GetConversion(cast1); 3724var cast2Conversion = model.GetConversion(cast2); 4300Assert.Equal(Conversion.Identity, info.ImplicitConversion); 4379var conv = model.GetConversion(syntax); 5538var conversion = model.ClassifyConversion(lambdaSyntax, otherFuncType); 5586var conversion = model.ClassifyConversion(nullSyntax, typeC); 5625var conversion = model.ClassifyConversion(lambdaSyntax, typeFuncB); 5672var conversion = model.ClassifyConversion(lambdaSyntax, typeFuncC); 5733var conversionA = model.ClassifyConversion(methodGroupSyntax, typeFuncA); 5737var conversionB = model.ClassifyConversion(methodGroupSyntax, typeFuncB); 5740var conversionC = model.ClassifyConversion(methodGroupSyntax, typeFuncC); 5991Assert.Equal(Conversion.UnsetConversion, foreachSymbolInfo.CurrentConversion);

2281var conv = speculativeModel.GetConversion(initializer);

14809var conv = model.GetConversion(creation.Type); 14905var conv = model.GetConversion(creation.Type); 15016var conv = model.GetConversion(creation.Type);

180var result = c.ClassifyConversionFromType(types[j], types[i], ref useSiteDiagnostics); 184var result2 = c.ClassifyConversionFromType(types[j], types[i], ref useSiteDiagnostics); // set breakpoint here if this test is failing... 400Conversion conversion = model.ClassifyConversion(sourceExpression1, targetType); 1737var elementConversion = BoundNode.GetConversion(boundForEach.ElementConversion, boundForEach.ElementPlaceholder);

214public Conversion ImplicitConversion = default(Conversion);

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

225var conversion = conversionOperation.GetConversion(); 278var originalConversion = originalConversionOperation.GetConversion(); 536var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 591var innerOriginalConversion = originalConversionOperation.GetConversion(); 602var outerOriginalConversion = outerOriginalConversionOperation.GetConversion(); 629var originalConversion = originalConversionOperation.GetConversion(); 655var rewrittenBitwiseNotConversion = rewrittenBitwiseNotConversionOperation.GetConversion(); 697var originalConversion = conversionOperation.GetConversion(); 837Conversion conversion, 896var conversion = semanticModel.GetConversion(castedExpressionNode, cancellationToken); 924var parentConversion = semanticModel.GetConversion(castNode, cancellationToken); 972var conversion = semanticModel.GetConversion(current, cancellationToken); 1054var oldConversion = oldForEachInfo.ElementConversion; 1055var newConversion = newForEachInfo.ElementConversion; 1312private static (ITypeSymbol? rewrittenConvertedType, Conversion rewrittenConversion) GetRewrittenInfo( 1315Conversion originalConversion, ITypeSymbol originalConvertedType, 1331var rewrittenConversion = rewrittenSemanticModel.GetConversion(rewrittenExpression, cancellationToken);

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

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

37Conversion> 396var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalOtherPartOfConditional, originalExpressionType); 397var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newOtherPartOfConditional, newExpressionType); 431var originalConversion = this.OriginalSemanticModel.ClassifyConversion(oldSwitchStatement.Expression, originalCaseType); 432var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newSwitchStatement.Expression, newCaseType); 534var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType); 535var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType); 693var originalConversion = this.OriginalSemanticModel.ClassifyConversion(originalIsOrAsExpression.Left, originalConvertedType, isExplicitInSource: true); 694var newConversion = this.SpeculativeSemanticModel.ClassifyConversion(newIsOrAsExpression.Left, newConvertedType, isExplicitInSource: true); 742var originalConversion = originalModel.GetConversion(originalExpression); 743var newConversion = newModel.GetConversion(newExpression); 780private bool ConversionsAreCompatible(Conversion originalConversion, Conversion newConversion) 822protected override Conversion ClassifyConversion(SemanticModel model, ExpressionSyntax expression, ITypeSymbol targetType) 825protected override Conversion ClassifyConversion(SemanticModel model, ITypeSymbol originalType, ITypeSymbol targetType)

833CSharp.Conversion csharpConversion = CSharp.CSharpExtensions.GetConversion(operation); 1162var inConversionInternal = CSharp.CSharpExtensions.GetInConversion(operation); 1163var outConversionInternal = CSharp.CSharpExtensions.GetOutConversion(operation);