9 overrides of RefKind
Microsoft.CodeAnalysis.CSharp (9)
Binder\Binder.ValueChecks.cs (1)
3387public override RefKind RefKind
Symbols\FunctionPointers\FunctionPointerParameterSymbol.cs (1)
27public override RefKind RefKind { get; }
Symbols\Metadata\PE\PEParameterSymbol.cs (1)
470public override RefKind RefKind
Symbols\SignatureOnlyParameterSymbol.cs (1)
50public override RefKind RefKind { get { return _refKind; } }
Symbols\Source\SourceClonedParameterSymbol.cs (1)
97public override RefKind RefKind
Symbols\Source\SourceParameterSymbol.cs (1)
215public sealed override RefKind RefKind
Symbols\Source\ThisParameterSymbol.cs (1)
153public override RefKind RefKind
Symbols\Synthesized\SynthesizedParameterSymbol.cs (1)
47public override RefKind RefKind => _refKind;
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
44public sealed override RefKind RefKind
406 references to RefKind
Microsoft.CodeAnalysis.CSharp (226)
Binder\Binder.ValueChecks.cs (22)
367Debug.Assert(parameter.RefKind.IsWritableReference() && parameter.Type.IsRefLikeOrAllowsRefLikeType()); 1415if (parameterSymbol.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && RequiresAssignableVariable(valueKind)) 1420else if (parameterSymbol.RefKind == RefKind.None && RequiresRefAssignableVariable(valueKind)) 1426Debug.Assert(parameterSymbol.RefKind != RefKind.None || !RequiresRefAssignableVariable(valueKind)); 1430if (parameterSymbol.RefKind == RefKind.None && 1529{ RefKind: RefKind.Out, UseUpdatedEscapeRules: true } => SafeContext.ReturnOnly, 1541{ RefKind: RefKind.None } => SafeContext.CurrentMethod, 1543{ HasUnscopedRefAttribute: true, UseUpdatedEscapeRules: true, RefKind: RefKind.Out } => SafeContext.ReturnOnly, 1576Debug.Assert(parameterSymbol.RefKind == RefKind.None || isRefScoped || refSafeToEscape.IsReturnOnly); 2358(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2586(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2717var refKind = parameter?.RefKind ?? RefKind.None; 2723parameter?.RefKind is RefKind.In or RefKind.RefReadOnlyParameter) 2725refKind = parameter.RefKind; 2735parameter.RefKind.IsWritableReference(); 2795refKind = thisParameter.RefKind; 2952return parameter.RefKind == RefKind.Ref && 3036if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel) 3043if (parameter.RefKind != RefKind.None && GetParameterRefEscapeLevel(parameter) is { } refEscapeLevel) 3107if (parameter.RefKind != RefKind.None && !parameter.IsThis) 3377Debug.Assert(underlyingParameter.RefKind != RefKind.Out); // Shouldn't get here for a constructor 3391if (_underlyingParameter.RefKind is not RefKind.None and var underlyingRefKind)
Binder\Binder_Attributes.cs (1)
252if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter))
Binder\Binder_Conversions.cs (3)
1494if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 3360sourceRefKind: delegateParameter.RefKind, 3361destinationRefKind: methodParameter.RefKind,
Binder\Binder_Deconstruct.cs (1)
690if (parameters[i].RefKind != RefKind.Out)
Binder\Binder_Expressions.cs (15)
2117if (IsBadLocalOrParameterCapture(parameter, parameter.Type, parameter.RefKind)) 2121if (parameter.RefKind != RefKind.None) 2141(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2144if (parameter.RefKind != RefKind.None) 2158else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } && 2617if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3873refKind = receiverParameter.RefKind; 3894refKind = parameter.RefKind; 3913refKind = parameter.RefKind; 3988if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 4002if (parameter.RefKind == RefKind.In) 4012else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 10659original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10760original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10761original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };
Binder\Binder_Invocation.cs (3)
1271if (receiverParameter.RefKind == RefKind.Ref) 1287else if (receiverParameter.RefKind == RefKind.In) 1374if (extensionParameter.RefKind == RefKind.Ref)
Binder\Binder_Operators.cs (4)
3846(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3908if (!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3909(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4243if (parameterSymbol.RefKind != RefKind.None)
Binder\Binder_Statements.cs (2)
2185var delegateRefKind = delegateParameters[i].RefKind; 2245var delegateRefKind = delegateParameters[i].RefKind;
Binder\ExecutableCodeBinder.cs (1)
115if (parameter.RefKind != RefKind.None)
Binder\ForEachLoopBinder.cs (1)
252else if (getEnumeratorMethod.IsExtensionBlockMember() && getEnumeratorMethod.ContainingType.ExtensionParameter.RefKind == RefKind.Ref)
Binder\RefSafetyAnalysis.cs (1)
1017!parameter.RefKind.IsWritableReference())
Binder\Semantics\Conversions\Conversions.cs (2)
439isParamsArray: parameter.IsParamsArray, isParamsCollection: parameter.IsParamsCollection, parameter.RefKind); 443analyzedArguments.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)
2451if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2801if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 3211[extension.ExtensionParameter.RefKind],
Binder\Semantics\OverloadResolution\OverloadResolution.cs (5)
2690return isExtensionParameterOfStaticExtensionMember ? RefKind.None : parameter.RefKind; 3794if (param1.RefKind != param2.RefKind) 3914hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None; 3967var paramRefKind = parameter.RefKind;
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (2)
1161if (parameters[i].RefKind != RefKind.None) 1231RefKind refParameter = parameter.RefKind;
BoundTree\BoundDagEvaluation.cs (1)
319Debug.Assert(parameter.RefKind == RefKind.Out);
BoundTree\BoundExpressionExtensions.cs (1)
28return ((BoundParameter)node).ParameterSymbol.RefKind;
BoundTree\UnboundLambda.cs (1)
1168refKindsBuilder.Add(p.RefKind);
CodeGen\CodeGenerator_HasHome.cs (1)
88((BoundParameter)expression).ParameterSymbol.RefKind is not (RefKind.In or RefKind.RefReadOnlyParameter);
CodeGen\CodeGenerator_RefSafety.cs (2)
100if (parameter.RefKind.IsWritableReference()) 105else if (parameter.RefKind != RefKind.None && parameter.EffectiveScope == ScopedKind.None)
CodeGen\EmitAddress.cs (1)
480if (parameterSymbol.RefKind == RefKind.None)
CodeGen\EmitExpression.cs (12)
962Debug.Assert(parameters.All(p => p.RefKind == RefKind.None) || !argRefKindsOpt.IsDefault, "there are nontrivial parameters, so we must have argRefKinds"); 988Debug.Assert(argRefKind == parameters[i].RefKind || 989parameters[i].RefKind switch 999Debug.Assert(parameters[i].RefKind != RefKind.RefReadOnlyParameter, 1003argRefKind = parameters[i].RefKind switch 1299return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 1435if (parameter.ParameterSymbol.RefKind != RefKind.None) 2244return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 2665if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2796return ((BoundParameter)left).ParameterSymbol.RefKind == RefKind.None; 2839if (left.ParameterSymbol.RefKind != RefKind.None && 3336if (parameter.ParameterSymbol.RefKind != RefKind.None && !refAssign)
CodeGen\EmitStatement.cs (1)
1319if (parameter.ParameterSymbol.RefKind == RefKind.None)
CodeGen\Optimizer.cs (1)
1050if (((BoundParameter)lhs).ParameterSymbol.RefKind != RefKind.None)
DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)
249if (symbol.RefKind != RefKind.None)
Emitter\EditAndContinue\CSharpSymbolMatcher.cs (6)
671return parameter.RefKind is RefKind.None == other.RefKind is RefKind.None && 701ValidateFunctionPointerParamOrReturn(param.TypeWithAnnotations, param.RefKind, param.RefCustomModifiers, allowOut: true); 702ValidateFunctionPointerParamOrReturn(otherParam.TypeWithAnnotations, otherParam.RefKind, otherParam.RefCustomModifiers, allowOut: true); 704return 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)
1442var thisRefKind = thisParameter.RefKind; 1557if (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); 1186((ParameterSymbol)symbol).RefKind == RefKind.Out) 1574if (isRef && param.RefKind == RefKind.Out) 1766if (parameter.RefKind != RefKind.Out) 1778if (thisParameter.RefKind != RefKind.Out) 1790if (extensionParameter.RefKind != RefKind.Out) 1813if (current is not MethodSymbol && parameter.RefKind == RefKind.Out) 1843if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async 1851NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1909if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor) 1921if (parameter.RefKind != RefKind.None)
FlowAnalysis\NullableWalker.cs (9)
1366var refKind = parameter.RefKind; 3004if (parameter.RefKind != RefKind.Out) 4618formalParameterRefKinds: [extensionParameter.RefKind], 6959return extensionParameter.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.None; 10926case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameter } when 11060VisitArgumentConversionAndInboundAssignmentsAndPreConditions(conversionOpt: null, variable.Expression, underlyingConversion, parameter.RefKind, 11074variable.Expression, parameter.RefKind, parameter, parameter.TypeWithAnnotations, GetRValueAnnotations(parameter), 11655ImmutableArray<RefKind> refKindsOpt = extensionParameter.RefKind == RefKind.Ref ? [RefKind.Ref] : default; 12982parameter.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\AsyncRewriter\RuntimeAsyncRewriter.cs (2)
56if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None }) 312Debug.Assert(thisParameter is not { Type.IsValueType: true, RefKind: RefKind.Ref });
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)
105var receiverRefKind = method.Parameters[0].RefKind;
Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (2)
309if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 455Debug.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)
1142symbol.Parameters.Any(static p => p.RefKind == RefKind.In))
Lowering\LocalRewriter\LocalRewriter_Call.cs (9)
254|| methodThisParameter.RefKind != interceptorThisParameterForCompare.RefKind: 300var thisRefKind = methodThisParameter.RefKind; 322argumentRefKindsOpt = method.Parameters.SelectAsArray(static param => param.RefKind); 899RefKind paramRefKind = parameters[paramIndex].RefKind; 954RefKind receiverRefKind = methodOrIndexer.ContainingType.ExtensionParameter.RefKind; 1221var paramRefKind = parameters[i].RefKind; 1419RefKind paramRefKind = parameters[p].RefKind; 1699RefKind paramRefKind = parameters[argIndex].RefKind;
Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (2)
258return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false }; 985((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)
312possiblyRefCapturedReceiver = _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)
490readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 528Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 535argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],
Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (1)
641return ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None;
Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)
500Debug.Assert(method.Parameters.AsSpan()[1..].All(static (p) => (p.IsOptional || p.IsParams) && p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));
Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (2)
222case ParameterSymbol { RefKind: RefKind.None }: 270Debug.Assert(parameter.IsThis || parameter.RefKind == RefKind.None);
Lowering\StateMachineRewriter\RefInitializationHoister.cs (2)
286or BoundParameter { ParameterSymbol.RefKind: RefKind.None }); 291or BoundParameter { ParameterSymbol.RefKind: RefKind.None })
Lowering\SynthesizedMethodBaseSymbol.cs (1)
126p.RefKind,
Symbols\Compilation_WellKnownMembers.cs (2)
1025handle(param.RefKind, param.RefCustomModifiers, param.TypeWithAnnotations); 1190return parameter.RefKind != RefKind.None;
Symbols\Extensions\SynthesizedExtensionMarker.cs (1)
91RefKind parameterRefKind = parameter.RefKind;
Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (1)
469originalParam.RefKind,
Symbols\MemberSignatureComparer.cs (2)
783var refKind1 = param1.RefKind; 784var 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)
1124switch (parameter.RefKind)
Symbols\NamedTypeSymbol.cs (2)
392if (thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) 397if (thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter
Symbols\ParameterSignature.cs (1)
46var refKind = parameter.RefKind;
Symbols\ParameterSymbol.cs (2)
167((refKind = RefKind) == RefKind.None || 473RefKind 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)
542internal override bool IsEffectivelyReadOnly => _reducedFrom.Parameters[0].RefKind is RefKind.In or RefKind.RefReadOnlyParameter;
Symbols\Retargeting\RetargetingSymbolTranslator.cs (2)
1008param.RefKind), 1082param.RefKind),
Symbols\Source\CustomModifierUtils.cs (1)
146destinationParameter.RefKind != RefKind.None ? sourceParameter.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty,
Symbols\Source\ExplicitInterfaceHelpers.cs (2)
438if (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) 449return IsRefScopedByDefault(parameter.UseUpdatedEscapeRules, parameter.RefKind);
Symbols\Source\SourceMemberContainerSymbol.cs (4)
2237var refKind1 = method1.Parameters[i].RefKind; 2238var refKind2 = method2.Parameters[i].RefKind; 4473if (methodParam.RefKind != RefKind.None) 4496methodParams[0].RefKind == RefKind.None &&
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (10)
1321overrideParameter.RefKind, 1330overrideParameter.RefKind, 1411p is { EffectiveScope: ScopedKind.None, RefKind: RefKind.Ref } or { EffectiveScope: ScopedKind.ScopedRef, RefKind: RefKind.Out } && 1422if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1428else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1439int nRefParameters = parameters.Count(p => p.RefKind is RefKind.Ref or RefKind.In or RefKind.RefReadOnlyParameter or RefKind.Out); 1444else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType())) 1542if (baseParameter.RefKind != overrideParameter.RefKind)
Symbols\Source\SourceMethodSymbol.cs (1)
71if (parameter.RefKind != RefKind.None)
Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)
779if (param.RefKind == RefKind.Out) 1410checkAndReportManagedTypes(param.Type, param.RefKind, param.GetNonNullSyntaxNode(), isParam: true, diagnostics);
Symbols\Source\SourceNamedTypeSymbol_Extension.cs (3)
334if (parameter.RefKind != RefKind.None) 402appendRefKind(extensionParameter.RefKind, builder, forParameter: true); 732appendRefKind(parameter.RefKind, builder, forParameter: true);
Symbols\Source\SourceOrdinaryMethodSymbol.cs (2)
212var parameter0RefKind = this.Parameters[0].RefKind; 865else if (IsPartial && !HasExplicitAccessModifier && Parameters.Any(static p => p.RefKind == RefKind.Out))
Symbols\Source\SourceParameterSymbolBase.cs (2)
100AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + parameter.RefCustomModifiers.Length, parameter.RefKind)); 119switch (parameter.RefKind)
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (4)
399switch (extensionParameter.RefKind) 430throw ExceptionUtilities.UnexpectedValue(extensionParameter.RefKind); 473if (p.RefKind != RefKind.None && p.RefKind != RefKind.In)
Symbols\SymbolExtensions.cs (1)
512refKind = 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\SynthesizedHotReloadExceptionConstructorSymbol.cs (1)
58delegateInvoke.GetParameters() is not [{ RefKind: RefKind.None } parameter] ||
Symbols\Synthesized\SynthesizedParameterSymbol.cs (2)
315oldParam.RefKind, 365Debug.Assert(baseParameterForAttributes is null || baseParameterForAttributes.RefKind == refKind);
Symbols\VarianceSafety.cs (1)
245requireOutputSafety: param.RefKind != RefKind.None,
Symbols\Wrapped\WrappedParameterSymbol.cs (1)
46get { return _underlyingParameter.RefKind; }
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (80)
CodeGen\CodeGenInParametersTests.cs (12)
4950m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.M1").Parameters.Single().RefKind); 4954m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.M2").Parameters.Single().RefKind); 5054m.GlobalNamespace.GetTypeMember("IntExtensions").GetTypeMembers().Single().ExtensionParameter.RefKind); 5058m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.M1").Parameters.Single().RefKind); 5062m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.get_P1").Parameters.Single().RefKind); 5066m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.set_P1").Parameters.First().RefKind); 5070m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.op_Addition").Parameters.First().RefKind); 5074m.GlobalNamespace.GetTypeMember("EnumExtensions").GetTypeMembers().Single().ExtensionParameter.RefKind); 5078m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.M1").Parameters.Single().RefKind); 5082m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.get_P1").Parameters.Single().RefKind); 5086m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.set_P1").Parameters.First().RefKind); 5090m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.op_Addition").Parameters.First().RefKind);
CodeGen\CodeGenReadonlyStructTests.cs (44)
829Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 830Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 831Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 846Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 847Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 848Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 853Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 854Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 855Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 860Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 861Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 862Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 867Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 868Assert.Equal(RefKind.Ref, namedType.GetMethod("M1").ThisParameter.RefKind); 869Assert.Equal(RefKind.Ref, namedType.GetMethod("ToString").ThisParameter.RefKind); 874Assert.Equal(RefKind.None, namedType.Constructors[0].ThisParameter.RefKind); 875Assert.Equal(RefKind.None, namedType.GetMethod("M1").ThisParameter.RefKind); 876Assert.Equal(RefKind.None, namedType.GetMethod("ToString").ThisParameter.RefKind); 881Assert.Equal(RefKind.None, namedType.Constructors[0].ThisParameter.RefKind); 882Assert.Equal(RefKind.None, namedType.GetMethod("Invoke").ThisParameter.RefKind); 913Assert.Equal(RefKind.Out, s1.Constructors[0].ThisParameter.RefKind); 914Assert.Equal(RefKind.In, s1.GetMethod("M1").ThisParameter.RefKind); 915Assert.Equal(RefKind.In, s1.GetMethod("ToString").ThisParameter.RefKind); 1003Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 1004Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 1005Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 1010Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 1011Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 1012Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 1017Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 1018Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 1019Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 1024Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 1025Assert.Equal(RefKind.In, namedType.GetMethod("M1").ThisParameter.RefKind); 1026Assert.Equal(RefKind.In, namedType.GetMethod("ToString").ThisParameter.RefKind); 1031Assert.Equal(RefKind.Out, namedType.Constructors[0].ThisParameter.RefKind); 1032Assert.Equal(RefKind.Ref, namedType.GetMethod("M1").ThisParameter.RefKind); 1033Assert.Equal(RefKind.Ref, namedType.GetMethod("ToString").ThisParameter.RefKind); 1038Assert.Equal(RefKind.None, namedType.Constructors[0].ThisParameter.RefKind); 1039Assert.Equal(RefKind.None, namedType.GetMethod("M1").ThisParameter.RefKind); 1040Assert.Equal(RefKind.None, namedType.GetMethod("ToString").ThisParameter.RefKind); 1045Assert.Equal(RefKind.None, namedType.Constructors[0].ThisParameter.RefKind); 1046Assert.Equal(RefKind.None, namedType.GetMethod("Invoke").ThisParameter.RefKind); 1608Assert.Equal(refKind, method.ThisParameter?.RefKind);
CodeGen\CodeGenRefOutTests.cs (12)
873m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.M1").Parameters.Single().RefKind); 877m.GlobalNamespace.GetMember<MethodSymbol>("Extensions.M2").Parameters.Single().RefKind); 977m.GlobalNamespace.GetTypeMember("IntExtensions").GetTypeMembers().Single().ExtensionParameter.RefKind); 981m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.M1").Parameters.Single().RefKind); 985m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.get_P1").Parameters.Single().RefKind); 989m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.set_P1").Parameters.First().RefKind); 993m.GlobalNamespace.GetMember<MethodSymbol>("IntExtensions.op_Addition").Parameters.First().RefKind); 997m.GlobalNamespace.GetTypeMember("EnumExtensions").GetTypeMembers().Single().ExtensionParameter.RefKind); 1001m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.M1").Parameters.Single().RefKind); 1005m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.get_P1").Parameters.Single().RefKind); 1009m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.set_P1").Parameters.First().RefKind); 1013m.GlobalNamespace.GetMember<MethodSymbol>("EnumExtensions.op_Addition").Parameters.First().RefKind);
Emit\EmitCustomModifiers.cs (3)
606Assert.Equal(RefKind.Ref, parameter.RefKind); 662Assert.Equal(RefKind.Ref, baseParameter.RefKind); 670Assert.Equal(RefKind.Ref, derivedParameter.RefKind);
Emit\EmitMetadataTests.cs (9)
449Assert.Equal(RefKind.Ref, parameter1.RefKind); 2027Assert.Equal(RefKind.None, m.Parameters[0].RefKind); 2028Assert.Equal(RefKind.Ref, m.Parameters[1].RefKind); 2029Assert.Equal(RefKind.Out, m.Parameters[2].RefKind); 2081Assert.Equal(invoke.Parameters[i].RefKind, beginInvoke.Parameters[i].RefKind); 2093if (invoke.Parameters[i].RefKind != RefKind.None) 2096Assert.Equal(invoke.Parameters[i].RefKind, endInvoke.Parameters[k++].RefKind);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (37)
Attributes\AttributeTests_RefReadOnly.cs (24)
42Assert.Equal(RefKind.In, parameter.RefKind); 68Assert.Equal(RefKind.In, parameter.RefKind); 124Assert.Equal(RefKind.In, parameter.RefKind); 154Assert.Equal(RefKind.In, parameter.RefKind); 206Assert.Equal(RefKind.In, parameter.RefKind); 233Assert.Equal(RefKind.In, parameter.RefKind); 277Assert.Equal(RefKind.In, parameter.RefKind); 406Assert.Equal(RefKind.In, parameter.RefKind); 426Assert.Equal(RefKind.In, parameter.RefKind); 478Assert.Equal(RefKind.In, parameter.RefKind); 505Assert.Equal(RefKind.In, parameter.RefKind); 522Assert.Equal(RefKind.In, parameter.RefKind); 565Assert.Equal(RefKind.In, parameter.RefKind); 602Assert.Equal(RefKind.In, parameter.RefKind); 626Assert.Equal(RefKind.In, parameter.RefKind); 690Assert.Equal(RefKind.In, parameter.RefKind); 729Assert.Equal(RefKind.In, parameter.RefKind); 757Assert.Equal(RefKind.In, parameter.RefKind); 823Assert.Equal(RefKind.In, parameter.RefKind); 1161Assert.Equal(RefKind.In, parameter.RefKind); 2370Assert.Equal(RefKind.RefReadOnly, method.Parameters[0].RefKind); 2371Assert.Equal(RefKind.Ref, method.Parameters[1].RefKind); 2417Assert.Equal(RefKind.Ref, method.Parameters[0].RefKind); 2418Assert.Equal(RefKind.RefReadOnly, method.Parameters[1].RefKind);
RefReadonlyParameterTests.cs (10)
64Assert.Equal(refKind, RefKind.RefReadOnlyParameter == parameter.RefKind); 1002Assert.Equal(RefKind.In, p.RefKind); 1099Assert.Equal(RefKind.Ref, p.RefKind); 1151Assert.Equal(RefKind.In, p.RefKind); 1253Assert.Equal(RefKind.Ref, p.RefKind); 1693Assert.Equal(RefKind.Ref, p.RefKind); 1712Assert.Equal(RefKind.In, p.RefKind); 7113var methodFromClass = comp.GetMembers("C.M").Cast<MethodSymbol>().Single(m => m.Parameters.Single().RefKind == refKind); 7141var methodFromClass = comp.GetMembers("C.M").Cast<MethodSymbol>().Single(m => m.Parameters.Single().RefKind == RefKind.RefReadOnlyParameter); 7184Assert.Equal(RefKind.Ref, parameter.RefKind);
Semantics\ExtensionTests.cs (1)
3880Assert.Equal(RefKind.RefReadOnlyParameter, m.GlobalNamespace.GetTypeMember("Extensions").GetTypeMembers().Single().ExtensionParameter.RefKind);
Semantics\RecordTests.cs (2)
14208Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 14211Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (6)
Semantics\LambdaTests.cs (3)
6891Assert.Equal(RefKind.Ref, lambdas[0].Parameters[0].RefKind); 6892Assert.Equal(RefKind.In, lambdas[1].Parameters[0].RefKind); 6893Assert.Equal(RefKind.Out, lambdas[2].Parameters[0].RefKind);
Semantics\RecordStructTests.cs (2)
3513Assert.Equal(RefKind.Out, deconstruct.Parameters[0].RefKind); 3516Assert.Equal(RefKind.Out, deconstruct.Parameters[1].RefKind);
Semantics\RefFieldTests.cs (1)
12025Assert.Equal(expectedRefKind, parameter.RefKind);
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (51)
Symbols\CompilationCreationTests.cs (2)
2357Assert.Equal(RefKind.Ref, x1.RefKind); 2362Assert.Equal(RefKind.Out, x2.RefKind);
Symbols\DefaultInterfaceImplementationTests.cs (1)
69335Assert.Equal(RefKind.In, p.RefKind);
Symbols\ExtensionMethodTests.cs (4)
4035Assert.Equal(RefKind.In, parameter.RefKind); 4041Assert.Equal(RefKind.In, parameter.RefKind); 4065Assert.Equal(RefKind.Ref, parameter.RefKind); 4071Assert.Equal(RefKind.Ref, parameter.RefKind);
Symbols\FunctionPointerTypeSymbolTests.cs (13)
472Assert.Equal(RefKind.Ref, firstParam.Parameters.Single().RefKind); 475Assert.Equal(RefKind.In, secondParam.Parameters.Single().RefKind); 478Assert.Equal(RefKind.Out, thirdParam.Parameters.Single().RefKind); 481Assert.Equal(RefKind.None, fourthParam.Parameters.Single().RefKind); 574Assert.Equal(RefKind.None, firstParam.Parameters.Single().RefKind); 577Assert.Equal(RefKind.None, secondParam.Parameters.Single().RefKind); 580Assert.Equal(RefKind.Ref, thirdParam.Parameters.Single().RefKind); 583Assert.Equal(RefKind.In, fourthParam.Parameters.Single().RefKind); 586Assert.Equal(RefKind.Out, fifthParam.Parameters.Single().RefKind); 589Assert.Equal(RefKind.In, sixthParam.Parameters.Single().RefKind); 592Assert.Equal(RefKind.Ref, seventhParam.Parameters.Single().RefKind); 595Assert.Equal(RefKind.Out, eightParam.Parameters.Single().RefKind); 598Assert.Equal(RefKind.Ref, ninthParam.Parameters.Single().RefKind);
Symbols\Metadata\MetadataMemberTests.cs (2)
286Assert.Equal(RefKind.Ref, p5.RefKind); 289Assert.Equal(RefKind.Out, p6.RefKind);
Symbols\Metadata\PE\DynamicTransformsTests.cs (3)
276Assert.Equal(RefKind.Ref, f2.Parameters[0].RefKind); 283Assert.Equal(RefKind.None, f3.Parameters[0].RefKind); 307Assert.Equal(RefKind.None, f4.Parameters[0].RefKind);
Symbols\Metadata\PE\LoadingIndexers.cs (1)
605Assert.Equal(RefKind.Ref, indexer.Parameters.Single().RefKind);
Symbols\PEParameterSymbolTests.cs (5)
112Assert.Equal(RefKind.Out, x.RefKind); 116Assert.Equal(RefKind.Ref, y.RefKind); 120Assert.Equal(RefKind.None, z.RefKind); 127Assert.Equal(RefKind.Out, x1.RefKind); 134Assert.Equal(RefKind.Ref, y2.RefKind);
Symbols\Source\DelegateTests.cs (6)
167Assert.Equal(invoke.Parameters[i].RefKind, beginInvoke.Parameters[i].RefKind); 179if (invoke.Parameters[i].RefKind != RefKind.None) 182Assert.Equal(invoke.Parameters[i].RefKind, endInvoke.Parameters[k++].RefKind); 801Assert.Equal(RefKind.In, d.DelegateInvokeMethod.Parameters[0].RefKind);
Symbols\Source\ExpressionBodiedPropertyTests.cs (2)
562Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind); 590Assert.Equal(RefKind.In, p.GetMethod.Parameters[0].RefKind);
Symbols\Source\MethodTests.cs (6)
364Assert.Equal(RefKind.Ref, p1.RefKind); 365Assert.Equal(RefKind.Out, p2.RefKind); 411Assert.Equal(RefKind.Ref, p1.RefKind); 455Assert.Equal(RefKind.Ref, p1.RefKind); 456Assert.Equal(RefKind.Out, p2.RefKind); 534Assert.Equal(RefKind.Ref, param.RefKind);
Symbols\SymbolErrorTests.cs (1)
3375Assert.Equal(RefKind.Ref, param.RefKind);
Symbols\TypeTests.cs (5)
514Assert.Equal(RefKind.Ref, p1.RefKind); 516Assert.Equal(RefKind.Out, p2.RefKind); 518Assert.Equal(RefKind.None, p3.RefKind); 1558Assert.Equal(RefKind.Ref, paras[0].RefKind); 1559Assert.Equal(RefKind.Out, paras[1].RefKind);
Microsoft.CodeAnalysis.CSharp.Test.Utilities (6)
Extensions.cs (3)
602Assert.Equal(propertyParam.RefKind, accessorParam.RefKind); 610Assert.Equal(RefKind.None, valueParameter.RefKind);
FunctionPointerUtilities.cs (3)
305Assert.Equal(argumentVerifiers[i].RefKind, parameter.RefKind); 307switch (parameter.RefKind) 326Assert.True(false, $"Cannot have a return ref kind of {parameter.RefKind}");