Exists

Binder\Binder_Conversions.cs (14)

220Debug.Assert(!conversion.Exists); 241|| !conversion.Exists); 263Debug.Assert(!conversion.Exists); 284if (!hasErrors && conversion.Exists) 1092Debug.Assert(elementConversions.All(c => c.Exists)); 2077if (!conversion.Exists) 2339if (!elementConversion.Exists) 2349if (!elementConversion.Exists) 2569Debug.Assert(toConversion.Exists); 2653conversion.Exists && 2658if (!conversion.Exists) 2676if (!conversion.Exists) 3334(Conversions.ConvertExtensionMethodThisArg(GetReceiverParameter(method)!.Type, receiverOpt!.Type, ref useSiteInfo, isMethodGroupConversion: true).Exists && useSiteInfo.Diagnostics.IsNullOrEmpty())); 3570if (!conversion.Exists)

Binder\Binder_Expressions.cs (3)

3010if (!underlyingConversion.Exists) 5635if (!conv.Exists) 10125if (!conversion.Exists)

Binder\Binder_Invocation.cs (3)

1231Debug.Assert(methodResult.Result.ConversionForArg(0).Exists); 1710&& Conversions.ClassifyBuiltInConversion(Compilation.GetSpecialType(SpecialType.System_String), parameterType, isChecked: false, ref discardedUseSiteInfo).Exists 1872if (!conversion.Exists)

Binder\Binder_Operators.cs (8)

1617if (implicitConversion.Exists) 5432if (conversion.Exists) 5672if (rightConversion.Exists) 5690if (rightConversion.Exists) 5741if (leftConversionClassification.Exists) 5755if (leftConversionClassification.Exists) 5805if (underlyingRightConversion.Exists && rightOperand.Type?.IsDynamic() != true) 5820if (rightConversion.Exists)

Binder\Binder_Patterns.cs (1)

782if (!conversion.Exists && (inputType.ContainsTypeParameter() || patternType.ContainsTypeParameter()))

Binder\DecisionDagBuilder.cs (1)

1813return (!conversion.Exists && isRuntimeSimilar(expressionType, patternType))

Binder\Semantics\BestTypeInferrer.cs (4)

146if (conversionsWithoutNullability.ClassifyImplicitConversionFromExpression(expr2, type1, ref useSiteInfo).Exists) 161if (conversionsWithoutNullability.ClassifyImplicitConversionFromExpression(expr1, type2, ref useSiteInfo).Exists) 290var t1tot2 = conversionsWithoutNullability.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(type1, type2, ref useSiteInfo).Exists; 291var t2tot1 = conversionsWithoutNullability.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(type2, type1, ref useSiteInfo).Exists;

Binder\Semantics\Conversions\Conversion.cs (3)

568if (!this.Exists) 633return Exists && !IsImplicit; 1154return new CommonConversion(Exists, IsIdentity, IsNumeric, IsReference, IsImplicit, IsNullable, methodSymbol, constrainedToType);

Binder\Semantics\Conversions\Conversions.cs (2)

210if (!elementConversion.Exists) 530if (spanConversion.Exists)

Binder\Semantics\Conversions\ConversionsBase.cs (60)

Binder\Semantics\Conversions\UserDefinedExplicitConversions.cs (8)

277if (!fromConversion.Exists && 280EncompassingExplicitConversion(source.GetNullableUnderlyingType(), convertsFrom, ref useSiteInfo).Exists) 286if (!toConversion.Exists && 289EncompassingExplicitConversion(convertsTo, target.GetNullableUnderlyingType(), ref useSiteInfo).Exists) 319if (fromConversion.Exists && toConversion.Exists) 327Debug.Assert(liftedFromConversion.Exists); 328Debug.Assert(liftedToConversion.Exists);

Binder\Semantics\Conversions\UserDefinedImplicitConversions.cs (5)

306if (fromConversion.Exists && toConversion.Exists) 354if (liftedFromConversion.Exists && liftedToConversion.Exists) 585return EncompassingImplicitConversion(aExpr, a, b, ref useSiteInfo).Exists;

Binder\Semantics\Operators\BinaryOperatorEasyOut.cs (2)

317Debug.Assert(leftConversion.Exists && leftConversion.IsImplicit); 318Debug.Assert(rightConversion.Exists && rightConversion.IsImplicit);

Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (2)

1620!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 1625else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)

Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (2)

228!Conversions.ConvertExtensionMethodThisArg(MakeNullable(candidate.Method.ContainingType.ExtensionParameter.Type), operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists) 233else if (!Conversions.ConvertExtensionMethodThisArg(candidate.Method.ContainingType.ExtensionParameter.Type, operand.Type, ref useSiteInfo, isMethodGroupConversion: false).Exists)

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (1)

3056return conversions.ClassifyImplicitConversionFromTypeWhenNeitherOrBothFunctionTypes(source, destination, ref useSiteInfo).Exists;

Binder\Semantics\OverloadResolution\OverloadResolution.cs (2)

4643if (!conversion.Exists) 4749Debug.Assert((!conversion.Exists) || conversion.IsImplicit, "ClassifyImplicitConversion should only return implicit conversions");

Binder\SwitchExpressionBinder.cs (1)

174if (!this.Conversions.ClassifyImplicitConversionFromExpression(@case.Value, commonType, ref useSiteInfo).Exists)

FlowAnalysis\NullableWalker.cs (9)

6129GenerateConversionForConditionalOperator(node.LeftOperand, leftType, rightType, reportMismatch: false, isChecked: node.Checked) is { Exists: true } conversion) 8077if (!conversion.Exists && !argumentNoConversion.IsSuppressed) 8885bool canConvertNestedNullability = conversion.Exists; 9785canConvertNestedNullability = conversion.Exists; 9811canConvertNestedNullability = conversion.Exists; 9863canConvertNestedNullability = conversion.Exists; 9881canConvertNestedNullability = conversion.Exists; 9892canConvertNestedNullability = conversion.Exists && conversion.IsSpan; 10374if (reportWarnings && !conversion.Exists)

Lowering\DiagnosticsPass_Warnings.cs (1)

288if (!node.Operator.Kind.IsDynamic() && node.LeftConversion is BoundConversion { Conversion: { IsIdentity: false, Exists: true } conversion })

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

218if (conversion.Exists)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (4)

1785if (!fromConversion.Exists) 1791if (!toConversion.Exists) 1891if (!fromConversion.Exists) 1897if (!toConversion.Exists)

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

50if (leftConversion is not BoundConversion { Conversion: { Exists: true } })

Operations\CSharpOperationFactory.cs (1)

1636if (valueConversion.Exists && !valueConversion.IsIdentity &&

Symbols\ReducedExtensionMethodSymbol.cs (1)

54if (!conversion.Exists)

Symbols\Source\ParameterHelpers.cs (1)

998else if (!conversion.Exists ||

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (1)

1208if (!conversion.Exists)

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\CSharpAddExplicitCastCodeFixProvider.cs (1)

103if (conversion.Exists && conversion.IsExplicit)

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)

154if (!model.Compilation.ClassifyConversion(typeArgument, returnExpressionType).Exists)

src\Analyzers\CSharp\Analyzers\UseDeconstruction\CSharpUseDeconstructionDiagnosticAnalyzer.cs (1)

154if (conversion is { Exists: true, IsIdentity: false, IsTupleConversion: false, IsTupleLiteralConversion: false })

src\Analyzers\CSharp\CodeFixes\AddExplicitCast\CSharpAddExplicitCastCodeFixProvider.cs (1)

103if (conversion.Exists && conversion.IsExplicit)

src\Analyzers\CSharp\CodeFixes\Iterator\CSharpAddYieldCodeFixProvider.cs (1)

154if (!model.Compilation.ClassifyConversion(typeArgument, returnExpressionType).Exists)

UseNamedArguments\CSharpUseNamedArgumentsCodeRefactoringProvider.cs (1)

50if (!conversion.Exists || conversion.IsExplicit)