RefKind

Binder\Binder.ValueChecks.cs (17)

146Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 1145if (parameterSymbol.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && RequiresAssignableVariable(valueKind)) 1150else if (parameterSymbol.RefKind == RefKind.None && RequiresRefAssignableVariable(valueKind)) 1156Debug.Assert(parameterSymbol.RefKind != RefKind.None || !RequiresRefAssignableVariable(valueKind)); 1160if (parameterSymbol.RefKind == RefKind.None && 1259{ RefKind: RefKind.Out, UseUpdatedEscapeRules: true } => SafeContext.ReturnOnly, 1271{ RefKind: RefKind.None } => SafeContext.CurrentMethod, 1273{ HasUnscopedRefAttribute: true, UseUpdatedEscapeRules: true, RefKind: RefKind.Out } => SafeContext.ReturnOnly, 1306Debug.Assert(parameterSymbol.RefKind == RefKind.None || isRefScoped || refSafeToEscape.IsReturnOnly); 2440var refKind = parameter?.RefKind ?? RefKind.None; 2446parameter?.RefKind is RefKind.In or RefKind.RefReadOnlyParameter) 2448refKind = parameter.RefKind; 2458parameter.RefKind.IsWritableReference(); 2518refKind = thisParameter.RefKind; 3099Debug.Assert(underlyingParameter.RefKind != RefKind.Out); // Shouldn't get here for a constructor 3113if (_underlyingParameter.RefKind is not RefKind.None and var underlyingRefKind) 4655if (constructMethod is not { Parameters: [{ RefKind: RefKind.None } parameter] })

Binder\Binder_Attributes.cs (1)

250if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter))

Binder\Binder_Conversions.cs (3)

1888if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 2874sourceRefKind: delegateParameter.RefKind, 2875destinationRefKind: methodParameter.RefKind,

Binder\Binder_Deconstruct.cs (1)

688if (parameters[i].RefKind != RefKind.Out)

Binder\Binder_Expressions.cs (14)

2140if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 2144if (parameter.RefKind != RefKind.None) 2164(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2167if (parameter.RefKind != RefKind.None) 2181else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } && 2542if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3808refKind = parameter.RefKind; 3827refKind = parameter.RefKind; 3900if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 3914if (parameter.RefKind == RefKind.In) 3924else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 10415original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10515original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10516original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };

Binder\Binder_Invocation.cs (3)

1265if (receiverParameter.RefKind == RefKind.Ref) 1281else if (receiverParameter.RefKind == RefKind.In) 1367if (extensionParameter.RefKind == RefKind.Ref)

Binder\Binder_Operators.cs (2)

2775(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3085if (parameterSymbol.RefKind != RefKind.None)

Binder\Binder_Statements.cs (2)

2155var delegateRefKind = delegateParameters[i].RefKind; 2215var delegateRefKind = delegateParameters[i].RefKind;

Binder\ExecutableCodeBinder.cs (1)

115if (parameter.RefKind != RefKind.None)

Binder\ForEachLoopBinder.cs (1)

252else if (getEnumeratorMethod.GetIsNewExtensionMember() && getEnumeratorMethod.ContainingType.ExtensionParameter.RefKind == RefKind.Ref) // Tracked by https://github.com/dotnet/roslyn/issues/76130: add test coverage for 'ref readonly' and 'in'

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

438isParamsArray: parameter.IsParamsArray, isParamsCollection: parameter.IsParamsCollection, parameter.RefKind); 442analyzedArguments.RefKinds.Add(parameter.RefKind);

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

1514delegateParameterRefKind: delegateParameters[p].RefKind, 1569if (delegateParameters[p].RefKind == RefKind.Out) 3399if (sourceParam.RefKind != destinationParam.RefKind) 3404if (!hasConversion(sourceParam.RefKind, destinationSig.Parameters[i].TypeWithAnnotations, sourceSig.Parameters[i].TypeWithAnnotations, ref useSiteInfo))

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

2449if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2799if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 3207[extension.ExtensionParameter.RefKind],

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

2595parameter1RefKind = parameter.RefKind; 2663if (p1.RefKind == RefKind.None && isAcceptableRefMismatch(p2.RefKind, isInterpolatedStringHandlerConversion)) 2674else if (p2.RefKind == RefKind.None && isAcceptableRefMismatch(p1.RefKind, isInterpolatedStringHandlerConversion)) 3777if (param1.RefKind != param2.RefKind) 3897hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None; 3950var paramRefKind = parameter.RefKind;

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

1122if (parameters[i].RefKind != RefKind.None) 1192RefKind refParameter = parameter.RefKind;

BoundTree\BoundExpressionExtensions.cs (1)

28return ((BoundParameter)node).ParameterSymbol.RefKind;

BoundTree\UnboundLambda.cs (1)

1132refKindsBuilder.Add(p.RefKind);

CodeGen\CodeGenerator_HasHome.cs (1)

88((BoundParameter)expression).ParameterSymbol.RefKind is not (RefKind.In or RefKind.RefReadOnlyParameter);

CodeGen\EmitAddress.cs (1)

480if (parameterSymbol.RefKind == RefKind.None)

CodeGen\EmitExpression.cs (12)

951Debug.Assert(parameters.All(p => p.RefKind == RefKind.None) || !argRefKindsOpt.IsDefault, "there are nontrivial parameters, so we must have argRefKinds"); 977Debug.Assert(argRefKind == parameters[i].RefKind || 978parameters[i].RefKind switch 988Debug.Assert(parameters[i].RefKind != RefKind.RefReadOnlyParameter, 992argRefKind = parameters[i].RefKind switch 1288return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 1424if (parameter.ParameterSymbol.RefKind != RefKind.None) 2217return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 2633if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2757return ((BoundParameter)left).ParameterSymbol.RefKind == RefKind.None; 2800if (left.ParameterSymbol.RefKind != RefKind.None && 3297if (parameter.ParameterSymbol.RefKind != RefKind.None && !refAssign)

CodeGen\EmitStatement.cs (1)

1292if (parameter.ParameterSymbol.RefKind == RefKind.None)

CodeGen\Optimizer.cs (1)

1040if (((BoundParameter)lhs).ParameterSymbol.RefKind != RefKind.None)

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

248if (symbol.RefKind != RefKind.None)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (6)

664return parameter.RefKind is RefKind.None == other.RefKind is RefKind.None && 694ValidateFunctionPointerParamOrReturn(param.TypeWithAnnotations, param.RefKind, param.RefCustomModifiers, allowOut: true); 695ValidateFunctionPointerParamOrReturn(otherParam.TypeWithAnnotations, otherParam.RefKind, otherParam.RefCustomModifiers, allowOut: true); 697return param.RefKind == otherParam.RefKind && AreTypesEqual(param.TypeWithAnnotations, otherParam.TypeWithAnnotations);

Emitter\Model\ParameterSymbolAdapter.cs (1)

41return AdaptedParameterSymbol.RefKind != RefKind.None;

Emitter\Model\ParameterTypeInformation.cs (1)

39return _underlyingParameter.RefKind != RefKind.None;

FlowAnalysis\AbstractFlowPass.cs (2)

1441var thisRefKind = thisParameter.RefKind; 1556if (method is null || Binder.GetCorrespondingParameter(i, method.Parameters, argsToParamsOpt, expanded)?.RefKind.IsWritableReference() != false)

FlowAnalysis\DataFlowsOutWalker.cs (1)

233((param.RefKind != RefKind.None && !param.IsImplicitlyDeclared && !RegionContains(param.GetFirstLocation().SourceSpan)) ||

FlowAnalysis\DefiniteAssignment.cs (11)

350NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1235((ParameterSymbol)symbol).RefKind == RefKind.Out) 1623if (isRef && param.RefKind == RefKind.Out) 1815if (parameter.RefKind != RefKind.Out) 1827if (thisParameter.RefKind != RefKind.Out) 1839if (extensionParameter.RefKind != RefKind.Out) 1862if (current is not MethodSymbol && parameter.RefKind == RefKind.Out) 1892if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async 1900NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1958if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor) 1970if (parameter.RefKind != RefKind.None)

FlowAnalysis\NullableWalker.cs (8)

1342var refKind = parameter.RefKind; 2979if (parameter.RefKind != RefKind.Out) 6546return extensionParameter.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.None; 10460case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameter } when 10596VisitArgumentConversionAndInboundAssignmentsAndPreConditions(conversionOpt: null, variable.Expression, underlyingConversion, parameter.RefKind, 10610variable.Expression, parameter.RefKind, parameter, parameter.TypeWithAnnotations, GetRValueAnnotations(parameter), 11085ImmutableArray<RefKind> refKindsOpt = extensionParameter.RefKind == RefKind.Ref ? [RefKind.Ref] : default; 12278parameter.RefKind,

FlowAnalysis\ReadWriteWalker.cs (3)

87if (p.RefKind != RefKind.None) _readOutside.Add(p); 90if (_symbol.TryGetInstanceExtensionParameter(out ParameterSymbol extensionParameter) && extensionParameter.RefKind != RefKind.None) 100if ((object)thisParameter != null && thisParameter.RefKind != RefKind.None)

Lowering\DiagnosticsPass_ExpressionTrees.cs (1)

619if (p.RefKind != RefKind.None && p.TryGetFirstLocation() is Location location)

Lowering\DiagnosticsPass_Warnings.cs (1)

244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true;

Lowering\ExtensionMethodReferenceRewriter.cs (1)

103var receiverRefKind = method.Parameters[0].RefKind;

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (2)

307if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 448Debug.Assert(parameter.RefKind == RefKind.None);

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (1)

186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload &&

Lowering\LocalRewriter\LocalRewriter.cs (1)

1128symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

189Debug.Assert(parameter.RefKind == RefKind.Out);

Lowering\LocalRewriter\LocalRewriter_Call.cs (7)

238|| methodThisParameter.RefKind != interceptorThisParameterForCompare.RefKind: 284var thisRefKind = methodThisParameter.RefKind; 882RefKind paramRefKind = parameters[paramIndex].RefKind; 1162var paramRefKind = parameters[i].RefKind; 1338RefKind paramRefKind = parameters[p].RefKind; 1631RefKind paramRefKind = parameters[argIndex].RefKind;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

912((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None ||

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (1)

171case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameterSymbol }:

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (1)

273possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref);

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

146if (unwrappedRight is { ConstantValueOpt: not null } or BoundLocal { LocalSymbol.IsRef: false } or BoundParameter { ParameterSymbol.RefKind: RefKind.None } &&

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (2)

186.All(p => p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 203if (initializer.InvokedAsExtensionMethod && addMethod.Parameters[0].RefKind == RefKind.Ref)

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (3)

443readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 481Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 488argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)

627return ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None;

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (1)

251Debug.Assert(parameter.IsThis || parameter.RefKind == RefKind.None);

Lowering\SynthesizedMethodBaseSymbol.cs (1)

126p.RefKind,

Symbols\Compilation_WellKnownMembers.cs (2)

1007handle(param.RefKind, param.RefCustomModifiers, param.TypeWithAnnotations); 1172return parameter.RefKind != RefKind.None;

Symbols\Extensions\SynthesizedExtensionMarker.cs (1)

84RefKind parameterRefKind = parameter.RefKind;

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (1)

469originalParam.RefKind,

Symbols\MemberSignatureComparer.cs (2)

811var refKind1 = param1.RefKind; 812var refKind2 = param2.RefKind;

Symbols\Metadata\PE\DynamicTypeDecoder.cs (1)

369var (transformedParamType, paramTransformed) = handle(ref this, param.RefKind, param.RefCustomModifiers, param.TypeWithAnnotations);

Symbols\Metadata\PE\MemberRefMetadataDecoder.cs (1)

254if ((candidateParam.RefKind != RefKind.None) != targetParam.IsByRef)

Symbols\Metadata\PE\PEMethodSymbol.cs (1)

1126switch (parameter.RefKind)

Symbols\NamedTypeSymbol.cs (2)

358if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 359(thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && thisParam.Type.TypeKind != TypeKind.Struct))

Symbols\ParameterSignature.cs (1)

46var refKind = parameter.RefKind;

Symbols\ParameterSymbol.cs (2)

167((refKind = RefKind) == RefKind.None || 457RefKind IParameterSymbolInternal.RefKind => RefKind;

Symbols\PropertySymbolExtensions.cs (2)

73if (param.RefKind == RefKind.Ref || param.RefKind == RefKind.Out)

Symbols\PublicModel\ParameterSymbol.cs (1)

59RefKind IParameterSymbol.RefKind => _underlying.RefKind;

Symbols\ReducedExtensionMethodSymbol.cs (1)

539internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind is RefKind.In or RefKind.RefReadOnlyParameter;

Symbols\Source\CustomModifierUtils.cs (1)

146destinationParameter.RefKind != RefKind.None ? sourceParameter.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty,

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

402if (implementedMemberParameters[i].RefKind != collisionCandidateParameters[i].RefKind)

Symbols\Source\ParameterHelpers.cs (4)

323refKind: parameter.RefKind, containingSymbol: parameter.ContainingSymbol, thisKeyword: thisKeyword, paramsKeyword: paramsKeyword, firstDefault: firstDefault, diagnostics: diagnostics); 348if (parameter.RefKind == RefKind.In) 359else if (parameter.RefKind == RefKind.RefReadOnlyParameter) 441return IsRefScopedByDefault(parameter.UseUpdatedEscapeRules, parameter.RefKind);

Symbols\Source\SourceMemberContainerSymbol.cs (4)

2198var refKind1 = method1.Parameters[i].RefKind; 2199var refKind2 = method2.Parameters[i].RefKind; 4464if (methodParam.RefKind != RefKind.None) 4487methodParams[0].RefKind == RefKind.None &&

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (9)

1306overrideParameter.RefKind, 1315overrideParameter.RefKind, 1396p is { EffectiveScope: ScopedKind.None, RefKind: RefKind.Ref } or { EffectiveScope: ScopedKind.ScopedRef, RefKind: RefKind.Out } && 1412else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1423int nRefParameters = parameters.Count(p => p.RefKind is RefKind.Ref or RefKind.In or RefKind.RefReadOnlyParameter or RefKind.Out); 1428else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType())) 1526if (baseParameter.RefKind != overrideParameter.RefKind)

Symbols\Source\SourceMethodSymbol.cs (1)

71if (parameter.RefKind != RefKind.None)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)

769if (param.RefKind == RefKind.Out) 1402checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);

Symbols\Source\SourceOrdinaryMethodSymbol.cs (2)

211var parameter0RefKind = this.Parameters[0].RefKind; 846else if (IsPartial && !HasExplicitAccessModifier && Parameters.Any(static p => p.RefKind == RefKind.Out))

Symbols\Source\SourceParameterSymbolBase.cs (2)

102AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + parameter.RefCustomModifiers.Length, parameter.RefKind)); 121switch (parameter.RefKind)

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (2)

419if (p.RefKind != RefKind.None && p.RefKind != RefKind.In)

Symbols\SymbolExtensions.cs (1)

511refKind = parameter.RefKind;

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

124if (ctor.ParameterCount == 1 && ctor.Parameters[0].RefKind == RefKind.None &&

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

148method.Parameters[0].RefKind == RefKind.None;

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

45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None &&

Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)

313oldParam.RefKind,

Symbols\VarianceSafety.cs (1)

245requireOutputSafety: param.RefKind != RefKind.None,

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

46get { return _underlyingParameter.RefKind; }