IsImplicit

RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (1)

528return conversion.IsReference && conversion.IsImplicit;

Binder\Binder_Await.cs (3)

477var result = conversion is { IsImplicit: true, Kind: ConversionKind.Identity or ConversionKind.ImplicitReference }; 495ref discardedUseSiteInfo).IsImplicit; 686if (!conversion.IsImplicit)

Binder\Binder_Conversions.cs (2)

2654Debug.Assert(fromReturnTypeConversion.IsImplicit); 2751Debug.Assert(analysis.TargetConversion is { IsIdentity: true } or { IsNullable: true, IsImplicit: true });

Binder\Binder_Deconstruct.cs (1)

328if (!nestedConversion.IsImplicit)

Binder\Binder_Expressions.cs (4)

1263if (!conversion.IsImplicit || !conversion.IsValid) 1312if (!conversion.IsImplicit || !conversion.IsValid) 5571if (!conversion.IsImplicit || !conversion.IsValid) 5583hasErrors = !conversion.IsImplicit;

Binder\Binder_Operators.cs (4)

295if (!rightToLeftConversion.IsImplicit || !rightToLeftConversion.IsValid) 704if (!argumentConversion.IsImplicit || !argumentConversion.IsValid) // NOTE: dev10 appears to allow user-defined conversions here. 1314Debug.Assert(!conversion.IsImplicit); 1646Debug.Assert(result.Conversion.IsImplicit);

Binder\Binder_Patterns.cs (3)

292if (!conversion.Exists || !conversion.IsImplicit || 1131if (Compilation.LanguageVersion < requiredVersion && !patternExpressionConversion.IsImplicit) 1903var result = Compilation.Conversions.ClassifyBuiltInConversion(type, possibleBaseInterface, isChecked: CheckOverflowAtRuntime, ref useSiteInfo).IsImplicit;

Binder\Binder_Statements.cs (7)

1378if (!elementConversionClassification.IsValid || !elementConversionClassification.IsImplicit) 1389elementConversionClassification.IsImplicit ? diagnostics : BindingDiagnosticBag.Discarded); 2004!conversion.IsImplicit : 2280Debug.Assert(!conversion.IsImplicit || !conversion.IsValid); 2471if (!conversion.IsImplicit || !conversion.IsValid) 2721if (conversion.IsImplicit) 3224else if (!conversion.IsImplicit || !conversion.IsValid)

Binder\Binder_TupleOperators.cs (1)

136if (conversion.IsImplicit)

Binder\DecisionDagBuilder.cs (1)

840if (input.Type.IsDynamic() ? type.SpecialType == SpecialType.System_Object : conversion.IsImplicit)

Binder\ForEachLoopBinder.cs (1)

588(collectionConversionClassification.IsImplicit &&

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

672return Exists && !IsImplicit; 1220return new CommonConversion(Exists, IsIdentity, IsNumeric, IsReference, IsImplicit, IsNullable, methodSymbol, constrainedToType);

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

124if (fastConversion.IsImplicit) 184return fastConversion.IsImplicit ? fastConversion : Conversion.NoConversion; 3025if (ClassifyImplicitConversionFromType(typeToCheck, targetInterfaceType, ref useSiteInfo).IsImplicit) 3059if (ClassifyImplicitConversionFromExpression(expressionToCheck, targetInterfaceType, ref useSiteInfo).IsImplicit)

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

1037Debug.Assert(targetConversion.Exists && targetConversion.IsImplicit);

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

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

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

744Debug.Assert(convLeft.IsImplicit); 745Debug.Assert(convRight.IsImplicit); 815if (convLeft.IsImplicit && convRight.IsImplicit)

Binder\Semantics\Operators\UnaryOperatorEasyOut.cs (1)

116Debug.Assert(conversion.HasValue && conversion.Value.IsImplicit);

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

535if (conversion.IsImplicit)

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

3104var t1IsConvertibleToT2 = Conversions.ClassifyImplicitConversionFromType(t1, t2, ref useSiteInfo).IsImplicit; 3105var t2IsConvertibleToT1 = Conversions.ClassifyImplicitConversionFromType(t2, t1, ref useSiteInfo).IsImplicit; 3224Conversions.ClassifyImplicitConversionFromType(source, destination, ref useSiteInfo).IsImplicit; 3521bool type1ToType2 = Conversions.ClassifyImplicitConversionFromType(type1, type2, ref useSiteInfo).IsImplicit; 3522bool type2ToType1 = Conversions.ClassifyImplicitConversionFromType(type2, type1, ref useSiteInfo).IsImplicit; 4751Debug.Assert((!conversion.Exists) || conversion.IsImplicit, "ClassifyImplicitConversion should only return implicit conversions");

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

1348Debug.Assert(!badArg.Result.ConversionForArg(parm).IsImplicit);

Binder\SwitchBinder.cs (1)

265else if (!conversion.IsImplicit)

BoundTree\BoundConversion.cs (3)

83if (ConversionGroupOpt.Conversion.IsImplicit) 119Debug.Assert(Conversion.IsImplicit); 204Debug.Assert(Conversion.IsImplicit);

Compiler\AnonymousTypeMethodBodySynthesizer.cs (1)

126Debug.Assert(c.IsImplicit);

FlowAnalysis\NullableWalker.cs (3)

10607Debug.Assert(analysis.TargetConversion is { IsIdentity: true } or { IsNullable: true, IsImplicit: true }); 12432else if (conversion.IsImplicit) 12637fromExplicitCast: !conversion.IsImplicit,

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

620Debug.Assert(c.IsImplicit);

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (2)

496Debug.Assert(c.IsImplicit); 649ref discardedUseSiteInfo).IsImplicit;

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (8)

178Debug.Assert(c.IsImplicit); 777Debug.Assert(c.IsImplicit); 939Debug.Assert(c.IsImplicit); 949Debug.Assert(c.IsImplicit); 966Debug.Assert(c.IsImplicit); 976Debug.Assert(c.IsImplicit); 1113Debug.Assert(c.IsImplicit); 1257Debug.Assert(c.IsImplicit);

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (2)

794Debug.Assert(c.IsImplicit); 804Debug.Assert(c.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_AsOperator.cs (1)

79if (conversion.IsImplicit)

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (2)

748if (conversion.IsImplicit) 772Debug.Assert(conversion.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

561Debug.Assert(c.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (7)

645Debug.Assert(c.IsImplicit || conversion.IsExplicit); 966Debug.Assert(analysis.TargetConversion is { IsIdentity: true } or { IsNullable: true, IsImplicit: true }); 1900var resultConversion = new Conversion(result, conversion.IsImplicit); 1922return TryMakeUserDefinedConversion(syntax, method, fromType, toType, @checked: @checked, conversion.IsImplicit); 1936return TryMakeUserDefinedConversion(syntax, method, fromType, toType, @checked: @checked, conversion.IsImplicit); 1953return TryMakeUserDefinedConversion(syntax, method, fromType, toType, @checked: @checked, conversion.IsImplicit); 1966return TryMakeUserDefinedConversion(syntax, method, fromType, toType, @checked: @checked, conversion.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_Event.cs (2)

313Debug.Assert(c0.IsImplicit); 319Debug.Assert(c1.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

510Debug.Assert(receiverConversion.IsImplicit);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

700Debug.Assert(_compilation.Conversions.ClassifyConversionFromType(rewrittenReceiver.Type, memberSymbol.ContainingType, isChecked: false, ref discardedUseSiteInfo).IsImplicit ||

Lowering\LocalRewriter\LocalRewriter_SwitchExpression.cs (2)

131Debug.Assert(c.IsImplicit); 159if (c.IsImplicit)

Lowering\SyntheticBoundNodeFactory.cs (1)

706Debug.Assert(c.IsImplicit);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorTypeSymbol.cs (1)

63Debug.Assert(c.IsImplicit);

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListTypeSymbol.cs (6)

490Debug.Assert(c.IsImplicit); 546Debug.Assert(c.IsImplicit); 589Debug.Assert(c.IsImplicit); 631Debug.Assert(c.IsImplicit); 655Debug.Assert(c.IsImplicit); 739Debug.Assert(c.IsImplicit);

Symbols\Synthesized\Records\SynthesizedRecordBaseEquals.cs (1)

68Debug.Assert(c.IsImplicit);

Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)

125Debug.Assert(c.IsImplicit);

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)

221Debug.Assert(c.IsImplicit);

Symbols\Synthesized\SynthesizedUnionCtor.cs (1)

68return c.Exists && c.IsImplicit && (c.IsIdentity || c.IsReference || c.IsBoxing);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (7)

234if (conversion.IsImplicit && 408if (originalParentConversion.IsImplicit) 767if (!innerOriginalConversion.IsImplicit || !innerOriginalConversion.IsNullable) 778if (!outerOriginalConversion.IsImplicit || !outerOriginalConversion.IsNullable) 805if (!originalConversion.IsImplicit || !originalConversion.IsNumeric) 983conditionalParentConversion.GetConversion().IsImplicit && 1023if (!outerConversion.IsImplicit)

src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)

180=> compilation.ClassifyConversion(sourceType, targetType).IsImplicit;

src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

142return conversion.IsImplicit && conversion.IsReference;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

610invocationTypes.Any(t => Compilation.ClassifyConversion(m.ReturnType, t).IsImplicit)).ToList();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

155=> compilation.ClassifyConversion(source: source, destination: destination).IsImplicit;

ConvertIfToSwitch\CSharpConvertIfToSwitchCodeRefactoringProvider.Analyzer.cs (1)

37semanticModel.ClassifyConversion(expressionSyntax, targetType).IsImplicit;

ExtractMethod\CSharpSelectionResult.ExpressionResult.cs (2)

116if (conv.IsImplicit && (conv.IsConstantExpression || conv.IsEnumeration)) 135if (!conversion.IsImplicit ||

GenerateType\CSharpGenerateTypeService.cs (1)

539=> compilation.ClassifyConversion(sourceType, targetType).IsImplicit;

src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)

180=> compilation.ClassifyConversion(sourceType, targetType).IsImplicit;

src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)

142return conversion.IsImplicit && conversion.IsReference;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (7)

234if (conversion.IsImplicit && 408if (originalParentConversion.IsImplicit) 767if (!innerOriginalConversion.IsImplicit || !innerOriginalConversion.IsNullable) 778if (!outerOriginalConversion.IsImplicit || !outerOriginalConversion.IsNullable) 805if (!originalConversion.IsImplicit || !originalConversion.IsNumeric) 983conditionalParentConversion.GetConversion().IsImplicit && 1023if (!outerConversion.IsImplicit)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)

610invocationTypes.Any(t => Compilation.ClassifyConversion(m.ReturnType, t).IsImplicit)).ToList();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\InitializeParameter\InitializeParameterHelpers.cs (1)

155=> compilation.ClassifyConversion(source: source, destination: destination).IsImplicit;

LoggerMessageGenerator.Parser.cs (1)

827return conversion.IsIdentity || (conversion.IsReference && conversion.IsImplicit);

Parser.cs (1)

731return conversion.IsReference && conversion.IsImplicit;

ParserUtilities.cs (1)

55return conversion.IsIdentity || (conversion.IsReference && conversion.IsImplicit);