RefKind

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

180unboundLambda.HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType); 187ImmutableArray<RefKind>.Empty,

Binder\Binder.QueryUnboundLambdaState.cs (3)

38public override bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 50public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }

Binder\Binder.ValueChecks.cs (121)

Binder\Binder_AnonymousTypes.cs (1)

96RefKind.None,

Binder\Binder_Attributes.cs (4)

252if (attributeConstructor.Parameters.Any(static p => p.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)) 484BindArgumentExpression(diagnostics, argument.Expression, RefKind.None, allowArglist: false), 486refKind: RefKind.None);

Binder\Binder_Conversions.cs (9)

1373argumentRefKinds = argumentRefKinds.Add(RefKind.None); 1494if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 2044parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds); 3383{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 3427RefKind sourceRefKind, RefKind destinationRefKind, bool checkingReturns, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 3432: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 3437if (sourceRefKind != RefKind.None)

Binder\Binder_Crefs.cs (7)

282refKind: RefKind.None, 313refKind: RefKind.None, 995refKind: RefKind.None, 1012refKind: RefKind.None, 1136RefKind refKind = parameter.RefKindKeyword.Kind().GetRefKind(); 1137if (refKind == RefKind.Ref && parameter.ReadOnlyKeyword.IsKind(SyntaxKind.ReadOnlyKeyword)) 1140refKind = RefKind.RefReadOnlyParameter;

Binder\Binder_Deconstruct.cs (2)

649analyzedArguments.RefKinds.Add(RefKind.Out); 690if (parameters[i].RefKind != RefKind.Out)

Binder\Binder_Expressions.cs (65)

491if (field is { IsStatic: false, RefKind: RefKind.None, ContainingSymbol: SourceMemberContainerTypeSymbol { PrimaryConstructor: { } primaryConstructor } } && 503RefKind refKind, 2038private bool IsBadLocalOrParameterCapture(Symbol symbol, TypeSymbol type, RefKind refKind) 2040if (refKind != RefKind.None || type.IsRestrictedType()) 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 } && 2311if (localSymbol.RefKind == RefKind.None && type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2617if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3171RefKind origRefKind = argumentSyntax.RefOrOutKeyword.Kind().GetRefKind(); 3175RefKind refKind = origRefKind == RefKind.None || RefMustBeObeyed(isDelegateCreation, argumentSyntax) ? origRefKind : RefKind.None; 3188if (!hadError && isDelegateCreation && origRefKind != RefKind.None && result.Arguments.Count == 1) 3195var requiredValueKind = origRefKind == RefKind.In ? BindValueKind.ReadonlyRef : BindValueKind.RefOrOut; 3207private BoundExpression BindArgumentValue(BindingDiagnosticBag diagnostics, ArgumentSyntax argumentSyntax, bool allowArglist, RefKind refKind) 3408RefKind refKind) 3416if (refKind != RefKind.None) 3426result.RefKinds.Add(RefKind.None); 3474private BoundExpression BindArgumentExpression(BindingDiagnosticBag diagnostics, ExpressionSyntax argumentExpression, RefKind refKind, bool allowArglist) 3477refKind == RefKind.None ? 3479refKind == RefKind.In ? 3850var argumentRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(handlerArgumentIndexes.Length); 3860RefKind refKind; 3866refKind = RefKind.None; 3952argumentRefKindsBuilder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 3976private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 3988if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 4000if (argRefKind == RefKind.Ref) 4002if (parameter.RefKind == RefKind.In) 4012else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 5118if (analyzedArguments.RefKind(i) is (RefKind.Ref or RefKind.Out)) 5715ArrayBuilder<RefKind> refKinds, 5908var rhsExpr = initializer.Right.CheckAndUnwrapRefExpression(diagnostics, out RefKind refKind); 5909bool isRef = refKind == RefKind.Ref; 6082ImmutableArray<RefKind> argumentRefKindsOpt = default; 8604extensionMethodArguments.RefKinds.Add(RefKind.None); 8754RefKind returnRefKind, 8836RefKind returnRefKind, 8946RefKind returnRefKind, 9209fieldSymbol.RefKind != RefKind.None) 10191RefKind refKind = analyzedArguments.RefKind(i); 10192if (refKind != RefKind.None) 10291default(ImmutableArray<RefKind>), 10409ImmutableArray<RefKind> argumentRefKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 10660original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10761original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10762original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 10825getMethod.RefKind == RefKind.None && 10869RefKind returnRefKind = default, 10893RefKind returnRefKind = default, 10925RefKind returnRefKind = default, 10996RefKind returnRefKind = default, 11462RefKind? returnRefKindOverride = null, 11469var returnRefKind = returnRefKindOverride ?? methodSymbol.RefKind; 11487if (returnsVoid && returnRefKind != RefKind.None) 11501returnRefKind == RefKind.None && 11503(parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)) && 11537parameterRefKinds.IsDefault ? RefKind.None : parameterRefKinds[i],

Binder\Binder_InterpolatedString.cs (8)

560ImmutableArray<RefKind> additionalConstructorRefKinds = default) 580ImmutableArray<RefKind> additionalConstructorRefKinds = default) 606ImmutableArray<RefKind> additionalConstructorRefKinds) 639ImmutableArray<RefKind> additionalConstructorRefKinds) 715var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(constructorArgumentLength); 716refKindsBuilder.Add(RefKind.None); 717refKindsBuilder.Add(RefKind.None); 727refKindsBuilder.Add(RefKind.Out);

Binder\Binder_Invocation.cs (15)

301else if (analyzedArguments.RefKind(i) == RefKind.None) 308case RefKind.None: 309case RefKind.Ref: 320ImmutableArray<RefKind> refKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 555ImmutableArray<RefKind> refKinds, 574if (refKinds[argIndex] == RefKind.In) 1271if (receiverParameter.RefKind == RefKind.Ref) 1284analyzedArguments.RefKinds[0] = RefKind.Ref; 1287else if (receiverParameter.RefKind == RefKind.In) 1290Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1372CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1374if (extensionParameter.RefKind == RefKind.Ref) 1533ArrayBuilder<RefKind>? argumentRefKindsBuilder, 1618argumentRefKindsBuilder.Add(RefKind.None); 1643argumentRefKindsBuilder.Add(RefKind.None);

Binder\Binder_Lambda.cs (9)

47ImmutableArray<RefKind> refKinds = default; 51RefKind returnRefKind = RefKind.None; 129var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(); 182var refKind = ParameterHelpers.GetModifiers(p.Modifiers, ignoreParams: false, out _, out var paramsKeyword, out _, out var scope); 222if (refKindsBuilder.Any(r => r != RefKind.None)) 292private (RefKind, ImmutableArray<CustomModifier> refCustomModifiers, TypeWithAnnotations) BindExplicitLambdaReturnType(TypeSyntax syntax, BindingDiagnosticBag diagnostics) 297syntax = syntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind); 316if (refKind == RefKind.RefReadOnly)

Binder\Binder_Operators.cs (15)

453analyzedArguments.RefKinds.Add(RefKind.Ref); 454analyzedArguments.RefKinds.Add(RefKind.None); 3545analyzedArguments.RefKinds.Add(RefKind.Ref); 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) 4274return localSymbol.RefKind != RefKind.None; 5874var whenTrue = node.WhenTrue.CheckAndUnwrapRefExpression(diagnostics, out var whenTrueRefKind); 5875var whenFalse = node.WhenFalse.CheckAndUnwrapRefExpression(diagnostics, out var whenFalseRefKind); 5877var isRef = whenTrueRefKind == RefKind.Ref && whenFalseRefKind == RefKind.Ref; 5880if (whenFalseRefKind == RefKind.Ref) 5885if (whenTrueRefKind == RefKind.Ref)

Binder\Binder_Query.cs (3)

701return lambdaBodyBinder.CreateBlockFromExpression(node, ImmutableArray<LocalSymbol>.Empty, RefKind.None, construction, null, d); 781return this.CreateBlockFromExpression(expression, locals, RefKind.None, result, expression, diagnostics); 823new AnonymousTypeField(fieldName, fieldValue.Syntax.Location, TypeWithAnnotations.Create(TypeOrError(fieldValue)), RefKind.None, ScopedKind.None);

Binder\Binder_Statements.cs (48)

Binder\ExecutableCodeBinder.cs (3)

115if (parameter.RefKind != RefKind.None) 141RefKind refKind = iterator.RefKind; 146if (refKind != RefKind.None)

Binder\ForEachLoopBinder.cs (13)

246if (getEnumeratorMethod.ParameterRefKinds is { IsDefault: false } refKinds && refKinds[0] == RefKind.Ref) 252else if (getEnumeratorMethod.IsExtensionBlockMember() && getEnumeratorMethod.ContainingType.ExtensionParameter.RefKind == RefKind.Ref) 333if (local.RefKind != RefKind.None) 346case RefKind.None: 349case RefKind.Ref: 352case RefKind.RefReadOnly: 484if (elementConversionClassification.Kind != ConversionKind.Identity && IterationVariable.RefKind is RefKind.Ref or RefKind.RefReadOnly) 886builder.CurrentPropertyGetter?.RefKind == (wellKnownSpan == WellKnownType.System_ReadOnlySpan_T ? RefKind.RefReadOnly : RefKind.Ref)) || 1213patternDisposeMethod.ParameterRefKinds.All(static refKind => refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));

Binder\InMethodBinder.cs (5)

128RefKind refKind = _methodSymbol.RefKind; 147RefKind refKind, TypeSymbol returnType, Location errorLocation, BindingDiagnosticBag diagnostics) 149if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType) 178internal static bool IsAsyncStreamInterface(CSharpCompilation compilation, RefKind refKind, TypeSymbol returnType) 180if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType)

Binder\LockBinder.cs (1)

80if (enterScopeMethod is not { ReturnsVoid: false, RefKind: RefKind.None })

Binder\RefSafetyAnalysis.cs (5)

553Debug.Assert(localSymbol.RefKind == RefKind.None || 567if (localSymbol.RefKind != RefKind.None) 584ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1257ImmutableArray<RefKind> refKinds; 1278AddLocalScopes(local, refEscapeScope: local.RefKind == RefKind.None ? _localScopeDepth : collectionEscape, valEscapeScope: collectionEscape);

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

1485if (anonymousFunction.HasExplicitReturnType(out var refKind, refCustomModifiers: out _, out var returnType)) 1569if (delegateParameters[p].RefKind == RefKind.Out) 3413bool hasConversion(RefKind refKind, TypeWithAnnotations sourceType, TypeWithAnnotations destinationType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 3417case RefKind.None:

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

1333if (op1.LeftRefKind == RefKind.None && op2.LeftRefKind == RefKind.In) 1337else if (op2.LeftRefKind == RefKind.None && op1.LeftRefKind == RefKind.In) 1346if (op1.RightRefKind == RefKind.None && op2.RightRefKind == RefKind.In) 1357else if (op2.RightRefKind == RefKind.None && op1.RightRefKind == RefKind.In)

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

92public RefKind LeftRefKind 108return RefKind.None; 112public RefKind RightRefKind 130return RefKind.None;

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

486if (op1.RefKind == RefKind.None && op2.RefKind == RefKind.In) 490else if (op2.RefKind == RefKind.None && op1.RefKind == RefKind.In)

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

46public RefKind RefKind 62return RefKind.None;

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

17public readonly ArrayBuilder<RefKind> RefKinds; 25this.RefKinds = new ArrayBuilder<RefKind>(32); 76public RefKind RefKind(int i) 78return RefKinds.Count > 0 ? RefKinds[i] : Microsoft.CodeAnalysis.RefKind.None; 101if ((object?)argument.Type != null && argument.Type.IsDynamic() && (!hasRefKinds || RefKinds[i] == Microsoft.CodeAnalysis.RefKind.None)) 149ImmutableArray<RefKind> argumentRefKindsOpt,

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

139private readonly ImmutableArray<RefKind> _formalParameterRefKinds; 277ImmutableArray<RefKind> formalParameterRefKinds, // Optional; assume all value if missing. 330ImmutableArray<RefKind> formalParameterRefKinds, 441private RefKind GetRefKind(int index) 444return _formalParameterRefKinds.IsDefault ? RefKind.None : _formalParameterRefKinds[index]; 1507RefKind delegateRefKind, 2451if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2461if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None) 2801if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2811if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None)

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

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

219RefKind? returnRefKind = null, 1161if (parameters[i].RefKind != RefKind.None) 1230RefKind refArg = arguments.RefKind(arg); 1231RefKind refParameter = parameter.RefKind; 1235Debug.Assert(refArg == RefKind.None); 1236if (refParameter == RefKind.Ref || refParameter == RefKind.In) 1294!(refArg == RefKind.None && refParameter == RefKind.In) && 1295!(refArg == RefKind.Ref && refParameter == RefKind.In && binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters)) && 1296!(refParameter == RefKind.RefReadOnlyParameter && refArg is RefKind.None or RefKind.Ref or RefKind.In)) 1301refParameter != RefKind.Out) 1306else if (refArg == RefKind.Ref && refParameter == RefKind.In && !binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters)) 1317else if (refParameter is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)

Binder\WithLambdaParametersBinder.cs (1)

47protected override TypeSymbol GetCurrentReturnType(out RefKind refKind)

BoundTree\BoundExpression.cs (1)

557ImmutableArray<RefKind> newRefKinds,

BoundTree\BoundExpressionExtensions.cs (8)

20public static RefKind GetRefKind(this BoundExpression node) 54return RefKind.Ref; 56return RefKind.RefReadOnly; 60return RefKind.None; 66return RefKind.None; 72EventSymbol => RefKind.None, 77return RefKind.None; 146delegateType is { DelegateInvokeMethod.OriginalDefinition: SynthesizedDelegateInvokeMethod { RefKind: RefKind.RefReadOnly } })

BoundTree\BoundNewT.cs (1)

15public override ImmutableArray<RefKind> ArgumentRefKindsOpt => default;

BoundTree\BoundNoPiaObjectCreationExpression.cs (1)

15public override ImmutableArray<RefKind> ArgumentRefKindsOpt => default;

BoundTree\BoundObjectCreationExpression.cs (3)

13ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ConstantValue? constantValueOpt, 18public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, 25ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt,

BoundTree\BoundObjectCreationExpressionBase.cs (1)

15public abstract ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }

BoundTree\BoundReturnStatement.cs (2)

13Debug.Assert(RefKind is RefKind.None or RefKind.Ref); // We assume that 'ref readonly' cannot be result of a return inference for a lambda.

BoundTree\Constructors.cs (28)

BoundTree\UnboundLambda.cs (52)

43internal readonly RefKind RefKind; 54RefKind refKind, 181ImmutableArray<RefKind> parameterRefKinds, 182RefKind refKind, 188parameterRefKinds.IsDefault ? Enumerable.Repeat(RefKind.None, parameterTypes.Length).ToImmutableArray() : parameterRefKinds, 219RefKind refKind = RefKind.None; 222RefKind rk = returnStatement.RefKind; 223if (rk != RefKind.None) 244Debug.Assert(refKind != RefKind.RefReadOnly); 410RefKind returnRefKind, 414ImmutableArray<RefKind> refKinds, 480public bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 505public RefKind RefKind(int index) { return Data.RefKind(index); } 595public abstract bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType); 602public abstract RefKind RefKind(int index); 677private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbol? invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers) 681refKind = CodeAnalysis.RefKind.None; 690internal (ImmutableArray<RefKind>, ArrayBuilder<ScopedKind>, ImmutableArray<TypeWithAnnotations>, bool) CollectParameterProperties() 692var parameterRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(ParameterCount); 699var refKind = RefKind(i); 757if (!HasExplicitReturnType(out var returnRefKind, refCustomModifiers: out _, out var returnType)) 821var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 840refKind == CodeAnalysis.RefKind.None && 861if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly) 928ImmutableArray<RefKind> parameterRefKinds, 929RefKind refKind, 945var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 978ImmutableArray<RefKind> parameterRefKinds) 980bool hasExplicitReturnType = HasExplicitReturnType(out var refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out var returnType); 1008Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1034Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1044ImmutableArray<RefKind> parameterRefKinds, 1046RefKind refKind, 1083public readonly ImmutableArray<RefKind> ParameterRefKinds; 1086public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null); 1088private ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations> parameterTypes, ImmutableArray<RefKind> parameterRefKinds, NamedTypeSymbol? taskLikeReturnTypeOpt) 1149out ImmutableArray<RefKind> parameterRefKinds, 1155parameterRefKinds = ImmutableArray<RefKind>.Empty; 1164var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameterCount); 1240?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty)); 1257ImmutableArray<RefKind> parameterRefKinds) 1260var refKind = inferredReturnType.RefKind; 1274refKind = CodeAnalysis.RefKind.None; 1488private readonly RefKind _returnRefKind; 1495private readonly ImmutableArray<RefKind> _parameterRefKinds; 1504RefKind returnRefKind, 1511ImmutableArray<RefKind> parameterRefKinds, 1537public override bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 1598public override RefKind RefKind(int index) 1601return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1635statements[0] is BoundReturnStatement { RefKind: Microsoft.CodeAnalysis.RefKind.None, ExpressionOpt: BoundExpression expr })

CodeGen\CodeGenerator.cs (1)

172var slotConstraints = _method.RefKind == RefKind.None

CodeGen\CodeGenerator_HasHome.cs (17)

88((BoundParameter)expression).ParameterSymbol.RefKind is not (RefKind.In or RefKind.RefReadOnlyParameter); 94return !((CodeGenerator.IsStackLocal(local, stackLocalsOpt) && local.RefKind == RefKind.None) || 95(!IsAnyReadOnly(addressKind) && local.RefKind == RefKind.RefReadOnly)); 98var methodRefKind = ((BoundCall)expression).Method.RefKind; 99return methodRefKind == RefKind.Ref || 100(IsAnyReadOnly(addressKind) && methodRefKind == RefKind.RefReadOnly); 104var dupRefKind = ((BoundDup)expression).RefKind; 105return dupRefKind == RefKind.Ref || 106(IsAnyReadOnly(addressKind) && dupRefKind == RefKind.RefReadOnly); 120var lhsRefKind = assignment.Left.GetRefKind(); 121return lhsRefKind == RefKind.Ref || 122(IsAnyReadOnly(addressKind) && lhsRefKind is RefKind.RefReadOnly or RefKind.RefReadOnlyParameter); 188if (field.RefKind is RefKind.Ref) 211if (field.RefKind == RefKind.RefReadOnly) 216Debug.Assert(field.RefKind == RefKind.None);

CodeGen\CodeGenerator_RefSafety.cs (7)

12/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 23/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 29returnRefKind: RefKind.None, 34/// <inheritdoc cref="MightEscapeTemporaryRefs(bool, TypeSymbol, RefKind, ParameterSymbol?, ImmutableArray{ParameterSymbol})"/> 64RefKind returnRefKind, 73if (used && (returnRefKind != RefKind.None || returnType.IsRefLikeOrAllowsRefLikeType())) 105else if (parameter.RefKind != RefKind.None && parameter.EffectiveScope == ScopedKind.None)

CodeGen\EmitAddress.cs (11)

36Debug.Assert(((BoundDup)expression).RefKind != RefKind.None, "taking address of a stack value?"); 123var funcPtrRefKind = funcPtrInvocation.FunctionPointer.Signature.RefKind; 124if (funcPtrRefKind == RefKind.Ref || 125(IsAnyReadOnly(addressKind) && funcPtrRefKind == RefKind.RefReadOnly)) 179var methodRefKind = call.Method.RefKind; 180return methodRefKind == RefKind.Ref || 181(IsAnyReadOnly(addressKind) && methodRefKind == RefKind.RefReadOnly); 274if (local.RefKind != RefKind.None) 480if (parameterSymbol.RefKind == RefKind.None) 554field.RefKind == RefKind.None ? 558_builder.EmitOpCode(field.RefKind == RefKind.None ? ILOpCode.Ldflda : ILOpCode.Ldfld);

CodeGen\EmitExpression.cs (59)

CodeGen\EmitStatement.cs (10)

759Debug.Assert(local.RefKind == RefKind.None || local.SynthesizedKind.IsLongLived(), 875if (boundReturnStatement.RefKind == RefKind.None) 883var unexpectedTemp = this.EmitAddress(expressionOpt, this._method.RefKind == RefKind.RefReadOnly ? AddressKind.ReadOnlyStrict : AddressKind.Writeable); 1170Debug.Assert(exceptionSourceLocal.LocalSymbol.RefKind == RefKind.None); 1182Debug.Assert(left.FieldSymbol.RefKind == RefKind.None); 1310if (local.RefKind == RefKind.None && !IsStackLocal(local)) 1319if (parameter.ParameterSymbol.RefKind == RefKind.None) 1793CSharpCompilation.DynamicTransformsEncoder.Encode(local.Type, RefKind.None, 0) : 1823Debug.Assert(local.RefKind == RefKind.None); 1839(local.RefKind != RefKind.None ? LocalSlotConstraints.ByRef : LocalSlotConstraints.None);

CodeGen\Optimizer.cs (24)

857if (node.LocalSymbol.RefKind != RefKind.None) 877if (node.LocalSymbol.RefKind != RefKind.None) 985if (localSymbol.RefKind is RefKind.RefReadOnly or RefKindExtensions.StrictIn && 1004else if (localSymbol.RefKind != RefKind.None && 1040(lhs.Kind is BoundKind.Local or BoundKind.Parameter or BoundKind.FieldAccess && lhs.GetRefKind() != RefKind.None), 1050if (((BoundParameter)lhs).ParameterSymbol.RefKind != RefKind.None) 1058if (((BoundLocal)lhs).LocalSymbol.RefKind != RefKind.None) 1066Debug.Assert(((BoundCall)lhs).Method.RefKind == RefKind.Ref, "only ref returning methods are assignable"); 1070Debug.Assert(((BoundFunctionPointerInvocation)lhs).FunctionPointer.Signature.RefKind == RefKind.Ref, "only ref returning function pointers are assignable"); 1230if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1264private ImmutableArray<BoundExpression> VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt) 1274RefKind argRefKind = CodeGenerator.GetArgumentRefKind(arguments, parameters, argRefKindsOpt, i); 1281private void VisitArgument(ImmutableArray<BoundExpression> arguments, ref ArrayBuilder<BoundExpression> rewrittenArguments, int i, RefKind argRefKind) 1283ExprContext context = (argRefKind == RefKind.None) ? ExprContext.Value : ExprContext.Address; 1305ImmutableArray<RefKind> argRefKindsOpt = node.ArgumentRefKindsOpt; 1309RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1437if (localSym.RefKind == RefKind.None) 1885Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1946return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2174var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2203left.LocalSymbol.RefKind == RefKind.Ref && 2440public override RefKind RefKind 2442get { return RefKind.None; }

Compilation\CSharpCompilation.cs (5)

2308if (method.RefKind != RefKind.None) 4158RefKind returnRefKind, 4160ImmutableArray<RefKind> parameterRefKinds, 4193if (returnRefKind == RefKind.Out) 4333fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None));

Compiler\ClsComplianceChecker.cs (2)

1327ImmutableArray<RefKind> xRefKinds; 1328ImmutableArray<RefKind> yRefKinds;

Compiler\MethodBodySynthesizer.cs (5)

50argumentRefKindsOpt: ImmutableArray<RefKind>.Empty, 195statement = new BoundReturnStatement(accessor.SyntaxNode, RefKind.None, fieldAccess, @checked: false); 313BoundStatement returnStatement = BoundReturnStatement.Synthesized(syntax, RefKind.None, processHandlerCall); 323BoundStatement returnStatement = new BoundReturnStatement(syntax, RefKind.None, expressionOpt: null, @checked: false); 360refKind: RefKind.None,

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (8)

671return parameter.RefKind is RefKind.None == other.RefKind is RefKind.None && 708private static void ValidateFunctionPointerParamOrReturn(TypeWithAnnotations type, RefKind refKind, ImmutableArray<CustomModifier> refCustomModifiers, bool allowOut) 713static bool verifyRefModifiers(ImmutableArray<CustomModifier> modifiers, RefKind refKind, bool allowOut) 715Debug.Assert(RefKind.RefReadOnly == RefKind.In); 718case RefKind.RefReadOnly: 719case RefKind.Out when allowOut:

Emitter\Model\FieldSymbolAdapter.cs (1)

56bool Cci.IFieldReference.IsByReference => AdaptedFieldSymbol.RefKind != RefKind.None;

Emitter\Model\ParameterSymbolAdapter.cs (1)

41return AdaptedParameterSymbol.RefKind != RefKind.None;

Emitter\Model\ParameterTypeInformation.cs (1)

39return _underlyingParameter.RefKind != RefKind.None;

Emitter\Model\PEModuleBuilder.cs (1)

1380!optArgList.ArgumentRefKindsOpt.IsDefaultOrEmpty && optArgList.ArgumentRefKindsOpt[i] != RefKind.None,

Emitter\Model\SpecializedFieldReference.cs (1)

80bool Cci.IFieldReference.IsByReference => _underlyingField.RefKind != RefKind.None;

FlowAnalysis\AbstractFlowPass.cs (37)

1131VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), null, default, false); 1292VisitRvalue(node.InitializerOpt, isKnownToBeAnLvalue: node.LocalSymbol.RefKind != RefKind.None); 1295if (node.LocalSymbol.RefKind != RefKind.None) 1436WriteArgument(receiverOpt, RefKind.Ref, method: null); 1442var thisRefKind = thisParameter.RefKind; 1516protected virtual void VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1523private void VisitArgumentsBeforeCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt) 1528RefKind refKind = GetRefKind(refKindsOpt, i); 1529if (refKind != RefKind.Out) 1531VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1544private void VisitArgumentsAfterCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol? method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1548RefKind refKind = GetRefKind(refKindsOpt, i); 1551case RefKind.None: 1552case RefKind.In: 1553case RefKind.RefReadOnlyParameter: 1556case RefKind.Ref: 1559goto case RefKind.Out; 1562case RefKind.Out: 1573protected static RefKind GetRefKind(ImmutableArray<RefKind> refKindsOpt, int index) 1575return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index]; 1578protected virtual void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2032VisitRvalue(node.ExpressionOpt, isKnownToBeAnLvalue: node.RefKind != RefKind.None); 2035if (node.RefKind != RefKind.None) 2146if (property.RefKind == RefKind.None) 2164var refKind = node.Left.Kind == BoundKind.BadExpression 2165? RefKind.Ref 2201if (property.RefKind == RefKind.None) 2220if (property.RefKind == RefKind.None) 2837if (property.RefKind == RefKind.None) 3339WriteArgument(operand, RefKind.Ref, method: null); 3525this.WriteArgument(operand, RefKind.Out, null); //Out because we know it will definitely be assigned. 3566VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.Constructor, default, false); 3650VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3656VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3664VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), method: null, default, false); 3756property.RefKind == RefKind.None)

FlowAnalysis\AlwaysAssignedWalker.cs (2)

73protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 76if (refKind == RefKind.Out)

FlowAnalysis\DataFlowsOutWalker.cs (1)

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

FlowAnalysis\DefiniteAssignment.cs (21)

350NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 811write: field.RefKind == RefKind.None || isRef); 923write: field.RefKind == RefKind.None || isRef); 1186((ParameterSymbol)symbol).RefKind == RefKind.Out) 1286if (fieldSymbol.RefKind != RefKind.None) 1470if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess) 1523if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 1574if (isRef && param.RefKind == RefKind.Out) 1592write: field.RefKind == RefKind.None || isRef); 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) 2523protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2525if (refKind == RefKind.Ref) 2539if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2731NoteWrite(iterationVariable, null, read: true, isRef: iterationVariable.RefKind != RefKind.None);

FlowAnalysis\FlowAnalysisPass.cs (3)

85var newStatements = block.Statements.Add(new BoundReturnStatement(trailingExpression.Syntax, RefKind.None, trailingExpression, @checked: false)); 141if (field.RefKind == RefKind.None) 205: BoundReturnStatement.Synthesized(syntax, RefKind.None, null);

FlowAnalysis\NullableWalker.cs (66)

FlowAnalysis\NullableWalker.PlaceholderLocal.cs (2)

59public override RefKind RefKind => RefKind.None;

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)

Generated\BoundNodes.xml.Generated.cs (40)

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

372unpendReturn = new BoundReturnStatement(_F.Syntax, RefKind.None, pendingValue, @checked: false);

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

488method.RefKind == RefKind.None &&

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (1)

444refKinds: ImmutableArray<RefKind>.Empty,

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\ClosureConversion\ClosureConversion.cs (7)

567new BoundReturnStatement(syntax, RefKind.None, null, @checked: false)); 879ref ImmutableArray<RefKind> argRefKinds) 920var refkindsBuilder = ArrayBuilder<RefKind>.GetInstance(argumentsBuilder.Count); 927refkindsBuilder.AddMany(RefKind.None, arguments.Length); 930refkindsBuilder.AddMany(RefKind.Ref, frameCount); 1344var argRefKinds = default(ImmutableArray<RefKind>); 1371ImmutableArray<RefKind> argRefKinds = default;

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

139public override RefKind RefKind => RefKind.None;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

119if (RefKind == RefKind.RefReadOnly)

Lowering\DiagnosticsPass_ExpressionTrees.cs (5)

308ImmutableArray<RefKind> argumentRefKindsOpt, 356else if (method.RefKind != RefKind.None) 553VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray<RefKind>), default(ImmutableArray<string>), default(ImmutableArray<int>), node.DefaultArguments, node); 577if (_inExpressionLambda && property.RefKind != RefKind.None) 619if (p.RefKind != RefKind.None && p.TryGetFirstLocation() is Location location)

Lowering\DiagnosticsPass_Warnings.cs (5)

21private void CheckArguments(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<BoundExpression> arguments, Symbol method) 28if (argumentRefKindsOpt[i] != RefKind.None) 235private static bool IsComCallWithRefOmitted(MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt) 244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true;

Lowering\ExtensionMethodReferenceRewriter.cs (7)

96ImmutableArray<RefKind> argumentRefKinds, 105var receiverRefKind = method.Parameters[0].RefKind; 109if (receiverRefKind != RefKind.None) 111var builder = ArrayBuilder<RefKind>.GetInstance(method.ParameterCount, RefKind.None); 147public static RefKind ReceiverArgumentRefKindFromReceiverRefKind(RefKind receiverRefKind)

Lowering\Extensions.cs (3)

17public static RefKind RefKinds(this ImmutableArray<RefKind> ArgumentRefKinds, int index) 25return RefKind.None;

Lowering\InitializerRewriter.cs (2)

68boundStatements.Add(new BoundReturnStatement(lastStatement.Syntax, RefKind.None, trailingExpression, @checked: false)); 106isRef: field.RefKind != RefKind.None)

Lowering\Instrumentation\CompoundInstrumenter.cs (1)

168ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\Instrumenter.cs (1)

242ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (6)

307if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 453Debug.Assert(parameter.RefKind == RefKind.None); 555ImmutableArray<RefKind> argumentRefKindsOpt = NullableWalker.AdjustArgumentRefKindsIfNeeded(original.ArgumentRefKindsOpt, adjustForExtensionBlockMethod, method, arguments.Length); 572private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds) 598if (refKinds[i] is not (RefKind.Ref or RefKind.Out))

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (4)

122ref ImmutableArray<RefKind> argumentRefKindsOpt) 131(argumentRefKindsOpt.IsDefault || argumentRefKindsOpt is [.., RefKind.None]) && 145argumentRefKindsOpt = argumentRefKindsOpt.IsDefault ? default : [.. argumentRefKindsOpt, RefKind.None]; 186member is MethodSymbol { Parameters: [.., { RefKind: RefKind.None, Type: { } lastParamType }] parametersWithCancellationToken } overload &&

Lowering\IteratorRewriter\IteratorConstructor.cs (1)

28SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 0, RefKind.None, GeneratedNames.MakeStateMachineStateFieldName()));

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (2)

140public override RefKind RefKind 142get { return RefKind.None; }

Lowering\LocalRewriter\LocalRewriter.cs (4)

1101return ((BoundCall)expr).Method.RefKind != RefKind.None; 1104return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1107return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None; 1142symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

163var refKindBuilder = ArrayBuilder<RefKind>.GetInstance(); 166void addArg(RefKind refKind, BoundExpression expression) 191Debug.Assert(parameter.RefKind == RefKind.Out); 193addArg(RefKind.Out, _tempAllocator.GetTemp(outputTemp)); 533&& loweredInput.GetRefKind() == RefKind.None &&

Lowering\LocalRewriter\LocalRewriter_AnonymousObjectCreation.cs (1)

28argumentRefKindsOpt: default(ImmutableArray<RefKind>),

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (7)

153ImmutableArray<RefKind> refKinds, 201default(ImmutableArray<RefKind>), 234Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None); 296ImmutableArray<RefKind> argumentRefKindsOpt, 328(arguments.Length != 0 || !IsSafeForReordering(rewrittenRight, RefKind.None))) 367if (!IsSafeForReordering(rewrittenRight, RefKind.None)) 369BoundLocal capturedRight = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);

Lowering\LocalRewriter\LocalRewriter_Call.cs (88)

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

663var call = _factory.New(constructor, arguments: [temp], argumentRefKinds: [asReadOnlySpan ? RefKindExtensions.StrictIn : RefKind.Ref]);

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (26)

233BoundLocal binaryResult = _factory.StoreToTemp(opFinal, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 258return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false }; 295RefKind refKind; 313refKind = variableRepresentsLocation ? RefKind.Ref : RefKind.None; 326refKind: refKind is RefKind.RefReadOnlyParameter ? RefKind.In : refKind, 444ImmutableArray<RefKind> argumentRefKinds = indexerAccess.ArgumentRefKindsOpt; 476ref ImmutableArray<RefKind> argumentRefKinds, 483ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 556Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None); 579var variableTemp = _factory.StoreToTemp(arrayAccess, out assignmentToTemp, refKind: RefKind.Ref); 657var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 728if (propertyAccess.PropertySymbol.RefKind == RefKind.None) 743if (indexerAccess.GetRefKind() == RefKind.None) 756if (implicitIndexerAccess.GetRefKind() == RefKind.None) 809Debug.Assert(originalLHS.GetRefKind() == RefKind.Ref); 830Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 834Debug.Assert(((BoundFunctionPointerInvocation)originalLHS).FunctionPointer.Signature.RefKind != RefKind.None); 885var variableTemp = _factory.StoreToTemp(rewrittenVariable, out assignmentToTemp2, refKind: RefKind.Ref); 985((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None || 989return localsMayBeAssignedOrCaptured || ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None;

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (2)

168case BoundLocal { LocalSymbol: { RefKind: RefKind.None } localSymbol }: 171case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameterSymbol }:

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (3)

36if (pinnedTemp.RefKind == RefKind.None) 264refKind: RefKind.RefReadOnly, 326refKind: RefKind.RefReadOnly,

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (5)

610RefKind collectionTempRefKind = RefKind.None; 698private delegate BoundStatement? GetForEachStatementAsForPreamble(LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind); 737return static (LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind) => 751collectionTempRefKind = enumeratorInfo.InlineArraySpanType == WellKnownType.System_Span_T ? RefKind.Ref : RefKindExtensions.StrictIn;

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (11)

54ImmutableArray<RefKind> refKinds) 107ImmutableArray<RefKind> argumentRefKindsOpt, 118if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 312possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref); 487Debug.Assert(!isLeftOfAssignment || node.IndexerOrSliceAccess.GetRefKind() == RefKind.Ref); 544receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 609if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 847receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);

Lowering\LocalRewriter\LocalRewriter_Literal.cs (2)

137argumentNamesOpt: default(ImmutableArray<string?>), argumentRefKindsOpt: default(ImmutableArray<RefKind>), expanded: false, 157argumentNamesOpt: default(ImmutableArray<string?>), argumentRefKindsOpt: default(ImmutableArray<RefKind>), expanded: false,

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (1)

47BoundLocal rightResult = _factory.StoreToTemp(loweredRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);

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_ObjectCreationExpression.cs (2)

43ImmutableArray<RefKind> argumentRefKindsOpt = node.ArgumentRefKindsOpt; 357default(ImmutableArray<RefKind>),

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (13)

171default(ImmutableArray<RefKind>), 186.All(p => p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 202var argumentRefKindsOpt = default(ImmutableArray<RefKind>); 203if (initializer.InvokedAsExtensionMethod && addMethod.Parameters[0].RefKind == RefKind.Ref) 208var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None); 209builder[0] = RefKind.Ref; 340memberInit.MemberSymbol?.GetParameterRefKinds() ?? default(ImmutableArray<RefKind>), 622ImmutableArray<RefKind> paramRefKindsOpt, 642elementArg.rewriter.EvaluateSideEffects(element, RefKind.None, elementArg.sideeffects, ref elementArg.temps), 670private BoundExpression EvaluateSideEffects(BoundExpression arg, RefKind refKind, ArrayBuilder<BoundExpression> sideeffects, ref ArrayBuilder<LocalSymbol>? temps)

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (2)

52if (isLeftOfAssignment && propertySymbol.RefKind == RefKind.None) 78ImmutableArray<RefKind> argumentRefKindsOpt,

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (4)

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_StringInterpolation.cs (2)

46if (construction.ArgumentRefKindsOpt[i] == RefKind.Out) 51Debug.Assert(construction.ArgumentRefKindsOpt[i] == RefKind.None);

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (3)

637return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 641return ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None; 669BoundLocal incrementResult = _factory.StoreToTemp(newValue, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (7)

500Debug.Assert(method.Parameters.AsSpan()[1..].All(static (p) => (p.IsOptional || p.IsParams) && p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 507Debug.Assert(method.ParameterRefKinds.IsDefaultOrEmpty || method.ParameterRefKinds.All(static refKind => refKind is RefKind.In or RefKind.RefReadOnlyParameter or RefKind.None)); 512ImmutableArray<RefKind> argumentRefKindsOpt = default;

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (54)

Lowering\MethodToClassRewriter.cs (1)

268if (leftLocal.LocalSymbol.RefKind != RefKind.None &&

Lowering\SpillSequenceSpiller.cs (42)

305RefKind refKind = RefKind.None, 317Debug.Assert(refKind == RefKind.None); 324Debug.Assert(refKind == RefKind.None); 337if (refKind != RefKind.None || expression.Type?.IsRefLikeOrAllowsRefLikeType() == true) 370var left = Spill(builder, assignment.Left, RefKind.Ref); 371var right = Spill(builder, assignment.Right, RefKind.Ref); 380if (refKind != RefKind.None || expression.Type.IsReferenceType) 388if (refKind != RefKind.None) 397if (local.LocalSymbol.SynthesizedKind == SynthesizedLocalKind.Spill || refKind != RefKind.None) 410if (refKind != RefKind.None || fieldSymbol.IsReadOnly) 417if (refKind == RefKind.None) goto default; 419var receiver = Spill(builder, field.ReceiverOpt, fieldSymbol.ContainingType.IsValueType ? refKind : RefKind.None); 437if (refKind != RefKind.None) 482if (refKind == RefKind.None && 489[Spill(builder, objectCreationExpression.Arguments[0], argRefKinds.IsDefault ? RefKind.None : argRefKinds[0])], 538Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } receiverRefLocal }, 541ValueTypeReceiver: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } valueTypeReceiver, 550Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 551Right: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } originalReceiverReference } 554Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 587ImmutableArray<RefKind> refKinds = default(ImmutableArray<RefKind>), 635var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 903expression = Spill(leftBuilder, expression, RefKind.None); 918left = Spill(leftBuilder, VisitExpression(ref leftBuilder, left), RefKind.Ref); 950expression = Spill(leftBuilder, expression, RefKind.None); 965receiver = Spill(leftBuilder, VisitExpression(ref leftBuilder, field.ReceiverOpt), RefKind.Ref); 1045RefKind refKind = ReceiverSpillRefKind(receiver); 1047Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1051if (refKind != RefKind.None && 1084private static RefKind ReceiverSpillRefKind(BoundExpression receiver) 1086var result = RefKind.None; 1089result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1278var receiverRefKind = ReceiverSpillRefKind(node.Receiver); 1299if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1302receiver = Spill(receiverBuilder, receiver, RefKind.None); 1317receiver = Spill(receiverBuilder, receiver, RefKind.Ref); 1319var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (6)

98Debug.Assert(local.RefKind != RefKind.None); 222case ParameterSymbol { RefKind: RefKind.None }: 223case LocalSymbol { RefKind: RefKind.None }: 224case FieldSymbol { RefKind: RefKind.None }: 232(variable is LocalSymbol { RefKind: not RefKind.None } refLocal && !canRefLocalBeHoisted(refLocal))) 270Debug.Assert(parameter.IsThis || parameter.RefKind == RefKind.None);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

317if (local.RefKind != RefKind.None)

Lowering\StateMachineRewriter\RefInitializationHoister.cs (23)

97var sacrificialTemp = _factory.SynthesizedLocal(type, refKind: RefKind.Ref); 137RefKind refKind, 155refKind: RefKind.None, 171refKind: RefKind.None, 192if (refKind != RefKind.None || field.FieldSymbol.IsReadOnly) return expr; 197if (refKind == RefKind.None) 207refKind: isFieldOfStruct ? refKind : RefKind.None, 238if (refKind != RefKind.None && refKind != RefKind.In) 240Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.Out); 241if (call.Method.RefKind != RefKind.None) 248refKind = RefKind.None; 259if (refKind != RefKind.None && refKind != RefKind.RefReadOnly) 261Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.In); 267refKind = RefKind.None; 276if (refKind != RefKind.None) 285Debug.Assert(_reportedError || expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 286or BoundParameter { ParameterSymbol.RefKind: RefKind.None }); 290if (expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 291or BoundParameter { ParameterSymbol.RefKind: RefKind.None })

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (2)

64public override RefKind RefKind => RefKind.None;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)

171if (local.RefKind != RefKind.None) 179Debug.Assert(local.RefKind == RefKind.None);

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

41public override RefKind RefKind 43get { return RefKind.None; }

Lowering\SynthesizedMethodBaseSymbol.cs (1)

141builder.Add(SynthesizedParameterSymbol.Create(this, this.TypeMap.SubstituteType(extra), ordinal++, RefKind.Ref));

Lowering\SyntheticBoundNodeFactory.cs (30)

575Debug.Assert(CurrentFunction.RefKind == RefKind.None); 580return new BoundReturnStatement(Syntax, CurrentFunction.RefKind != RefKind.None ? RefKind.Ref : RefKind.None, expression, @checked: false) { WasCompilerGenerated = true }; 600RefKind refKind = RefKind.None, 640return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 778public BoundObjectCreationExpression New(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKinds) 888public static ImmutableArray<RefKind> ArgumentRefKindsFromParameterRefKinds(MethodSymbol method, bool useStrictArgumentRefKinds) 892if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 893(useStrictArgumentRefKinds && result.Contains(RefKind.In)))) 895var builder = ArrayBuilder<RefKind>.GetInstance(result.Length); 897foreach (var refKind in result) 908public static RefKind ArgumentRefKindFromParameterRefKind(RefKind refKind, bool useStrictArgumentRefKinds) 912RefKind.In or RefKind.RefReadOnlyParameter when useStrictArgumentRefKinds => RefKindExtensions.StrictIn, 913RefKind.RefReadOnlyParameter => RefKind.In, 918public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1647RefKind refKind = RefKind.None, 1664case RefKind.Out: 1665refKind = RefKind.Ref; 1668case RefKind.In: 1677Debug.Assert(argument.GetRefKind() != RefKind.In); 1678refKind = RefKind.None; 1682case RefKind.None: 1683case RefKind.Ref: 1714isRef: refKind != RefKind.None);

Operations\CSharpOperationFactory.cs (6)

767ImmutableArray<RefKind> argumentRefKinds = boundDynamicObjectCreationExpression.ArgumentRefKindsOpt.NullToEmpty(); 796ImmutableArray<RefKind> argumentRefKinds = boundDynamicInvocation.ArgumentRefKindsOpt.NullToEmpty(); 839ImmutableArray<RefKind> argumentRefKinds = boundDynamicIndexerAccess.ArgumentRefKindsOpt.NullToEmpty(); 878ImmutableArray<RefKind> argumentRefKinds = boundObjectInitializerMember.ArgumentRefKindsOpt.NullToEmpty(); 899MethodSymbol? accessor = isObjectOrCollectionInitializer || property.RefKind != RefKind.None 996return new DynamicInvocationOperation(operation, arguments, argumentNames: ImmutableArray<string?>.Empty, argumentRefKinds: ImmutableArray<RefKind>.Empty, _semanticModel, syntax, type, isImplicit);

SymbolDisplay\SymbolDisplayVisitor.cs (1)

254if (symbol.RefKind == RefKind.RefReadOnly)

SymbolDisplay\SymbolDisplayVisitor.Members.cs (9)

39case RefKind.Ref: 42case RefKind.RefReadOnly: 852symbol.RefKind != RefKind.Out && 873symbol.RefKind == RefKind.None && 1134private void AddParameterRefKind(RefKind refKind) 1138case RefKind.Out: 1142case RefKind.Ref: 1146case RefKind.In: 1150case RefKind.RefReadOnlyParameter:

Symbols\AnonymousTypes\AnonymousTypeField.cs (2)

23public readonly RefKind RefKind; 40RefKind refKind,

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

253if (fields.Any(static f => f.RefKind != RefKind.None))

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (3)

33paramsArr.Add(SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name)); 53public override RefKind RefKind 55get { return RefKind.None; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (5)

61new SynthesizedDelegateInvokeMethod.ParameterDescription(TypeWithAnnotations.Create(typeParams[i]), refKinds.IsNull ? RefKind.None : refKinds[i], ScopedKind.None, defaultValue: null, isParams: false, hasUnscopedRefAttribute: false)); 66var returnRefKind = (refKinds.IsNull || voidReturnTypeOpt is { }) ? RefKind.None : refKinds[parameterCount]; 147var returnRefKind = returnParameter.RefKind; 208var returnRefKind = returnParameter.RefKind;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.EqualsMethodSymbol.cs (3)

25SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(this.Manager.System_Object), 0, RefKind.None, "value")); 38public override RefKind RefKind 40get { return RefKind.None; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (2)

35public override RefKind RefKind => RefKind.None;

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.GetHashCodeMethodSymbol.cs (2)

42public override RefKind RefKind 44get { return RefKind.None; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertyAccessorSymbol.cs (2)

39public override RefKind RefKind 41get { return RefKind.None; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (2)

64public override RefKind RefKind 66get { return RefKind.None; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ToStringMethodSymbol.cs (2)

42public override RefKind RefKind 44get { return RefKind.None; }

Symbols\BaseTypeAnalysis.cs (1)

203if (field.RefKind != RefKind.None)

Symbols\Compilation_WellKnownMembers.cs (13)

793internal SynthesizedAttributeData? SynthesizeDynamicAttribute(TypeSymbol type, int customModifiersCount, RefKind refKindOpt = RefKind.None) 798if (type.IsDynamic() && refKindOpt == RefKind.None && customModifiersCount == 0) 907internal static ImmutableArray<TypedConstant> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount, TypeSymbol booleanType) 919internal static ImmutableArray<bool> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount) 926internal static ImmutableArray<bool> EncodeWithoutCustomModifierFlags(TypeSymbol type, RefKind refKind) 933internal static void Encode(TypeSymbol type, int customModifiersCount, RefKind refKind, ArrayBuilder<bool> transformFlagsBuilder, bool addCustomModifierFlags) 937if (refKind != RefKind.None) 1028void handle(RefKind refKind, ImmutableArray<CustomModifier> customModifiers, TypeWithAnnotations twa) 1035if (refKind != RefKind.None) 1190return parameter.RefKind != RefKind.None; 1195return method.RefKind != RefKind.None; 1200return property.RefKind != RefKind.None;

Symbols\ErrorMethodSymbol.cs (2)

160public override RefKind RefKind 162get { return RefKind.None; }

Symbols\ErrorPropertySymbol.cs (2)

44public override RefKind RefKind { get { return RefKind.None; } }

Symbols\Extensions\SynthesizedExtensionMarker.cs (6)

25MethodKind.Ordinary, RefKind.None, GetDeclarationModifiers(), returnsVoid: false, returnsVoidIsSet: false, 91RefKind parameterRefKind = parameter.RefKind; 100else if (parameterRefKind == RefKind.Ref && !parameterType.IsValueType) 104else if (parameterRefKind is RefKind.In or RefKind.RefReadOnlyParameter 110if (parameter.Name is "" && parameterRefKind != RefKind.None)

Symbols\FieldSymbol.cs (2)

66public abstract RefKind RefKind { get; } 356if (DeriveUseSiteInfoFromType(ref result, this.TypeWithAnnotations, RefKind == RefKind.None ? AllowedRequiredModifierType.System_Runtime_CompilerServices_Volatile : AllowedRequiredModifierType.None) ||

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (48)

28RefKind refKind = RefKind.None; 44case SyntaxKind.RefKeyword when refKind == RefKind.None: 48refKind = RefKind.RefReadOnly; 53refKind = RefKind.Ref; 59Debug.Assert(refKind != RefKind.None); 73if (returnType.IsVoidType() && refKind != RefKind.None) 88if (refKind != RefKind.None) 247RefKind returnRefKind, 250ImmutableArray<RefKind> parameterRefKinds, 271RefKind returnRefKind, 273ImmutableArray<RefKind> parameterRefKinds, 285if (returnRefKind == RefKind.None) 310private static CustomModifier? GetCustomModifierForRefKind(RefKind refKind, CSharpCompilation compilation) 312Debug.Assert(refKind is RefKind.None or RefKind.In or RefKind.Ref or RefKind.Out); 316RefKind.In => compilation.GetWellKnownType(WellKnownType.System_Runtime_InteropServices_InAttribute), 317RefKind.Out => compilation.GetWellKnownType(WellKnownType.System_Runtime_InteropServices_OutAttribute), 323Debug.Assert(refKind != RefKind.Out && refKind != RefKind.In); 351var returnVariance = RefKind == RefKind.None ? variance : VarianceKind.None; 366(VarianceKind.In, RefKind.None) => VarianceKind.Out, 367(VarianceKind.Out, RefKind.None) => VarianceKind.In, 443RefKind refKind, 488RefKind refKind, 493ImmutableArray<RefKind> parameterRefKinds, 496Debug.Assert(refKind != RefKind.Out); 497Debug.Assert(refCustomModifiers.IsDefaultOrEmpty || refKind != RefKind.None); 509Debug.Assert(refCustomModifiers.IsEmpty || refKind != RefKind.None); 513static ImmutableArray<CustomModifier> getCustomModifierArrayForRefKind(RefKind refKind, CSharpCompilation compilation) 519RefKind refKind, 553RefKind = getRefKind(retInfo, RefCustomModifiers, RefKind.RefReadOnly, RefKind.Ref, requiresLocationAllowed: false); 554Debug.Assert(RefKind != RefKind.Out); 569RefKind paramRefKind = getRefKind(param, paramRefCustomMods, RefKind.In, RefKind.Out, requiresLocationAllowed: true); 581static RefKind getRefKind(ParamInfo<TypeSymbol> param, ImmutableArray<CustomModifier> paramRefCustomMods, RefKind hasInRefKind, RefKind hasOutRefKind, bool requiresLocationAllowed) 585false => RefKind.None, 588true when requiresLocationAllowed && CustomModifierUtils.HasRequiresLocationAttributeModifier(paramRefCustomMods) => RefKind.RefReadOnlyParameter, 589true => RefKind.Ref, 648var modifiersToSearch = RefKind != RefKind.None ? RefCustomModifiers : ReturnTypeWithAnnotations.CustomModifiers; 671var modifiersToSearch = RefKind != RefKind.None ? RefCustomModifiers : ReturnTypeWithAnnotations.CustomModifiers; 767public override RefKind RefKind { get; }

Symbols\FunctionPointers\FunctionPointerParameterSymbol.cs (5)

16public FunctionPointerParameterSymbol(TypeWithAnnotations typeWithAnnotations, RefKind refKind, int ordinal, FunctionPointerMethodSymbol containingSymbol, ImmutableArray<CustomModifier> refCustomModifiers) 27public override RefKind RefKind { get; } 81internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 82internal override bool IsMetadataOut => RefKind == RefKind.Out;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (13)

36RefKind returnRefKind, 39ImmutableArray<RefKind> parameterRefKinds, 50RefKind returnRefKind, 52ImmutableArray<RefKind> parameterRefKinds, 190internal static bool RefKindEquals(TypeCompareKind compareKind, RefKind refKind1, RefKind refKind2) 192? (refKind1 == RefKind.None) == (refKind2 == RefKind.None) 201internal static RefKind GetRefKindForHashCode(RefKind refKind) 202=> refKind == RefKind.None ? RefKind.None : RefKind.Ref;

Symbols\LocalSymbol.cs (2)

375public bool IsRef => RefKind != RefKind.None; 377public abstract RefKind RefKind

Symbols\MemberSignatureComparer.cs (14)

251/// the difference between <see cref="RefKind.Out"/> and <see cref="RefKind.Ref"/>. 553RefKind refKind1; 558RefKind refKind2; 783var refKind1 = param1.RefKind; 784var refKind2 = param2.RefKind; 799if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None)) 808static bool areRefKindsCompatible(RefKindCompareMode refKindCompareMode, RefKind refKind1, RefKind refKind2) 817return (refKind1, refKind2) is (RefKind.RefReadOnlyParameter, RefKind.In) or (RefKind.In, RefKind.RefReadOnlyParameter);

Symbols\MemberSymbolExtensions.cs (2)

323internal static ImmutableArray<RefKind> GetParameterRefKinds(this Symbol member) 332return default(ImmutableArray<RefKind>);

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

69RefKind targetSymbolRefKind = RefKind.None) 89RefKind targetSymbolRefKind, 107RefKind targetSymbolRefKind, 209private bool HandleRefKind(RefKind refKind) 212return refKind == RefKind.None || !ConsumeFlag(); 398static (TypeWithAnnotations, bool madeChanges) handle(ref DynamicTypeDecoder decoder, RefKind refKind, ImmutableArray<CustomModifier> refCustomModifiers, TypeWithAnnotations typeWithAnnotations)

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

183(field.RefKind != RefKind.None) == fieldInfo.IsByRef && 254if ((candidateParam.RefKind != RefKind.None) != targetParam.IsByRef)

Symbols\Metadata\PE\PEFieldSymbol.cs (9)

88public void SetRefKind(RefKind refKind) 95public RefKind RefKind => (RefKind)((_bits >> RefKindOffset) & RefKindMask); 325RefKind refKind = fieldInfo.IsByRef ? 326moduleSymbol.Module.HasIsReadOnlyAttribute(_handle) ? RefKind.RefReadOnly : RefKind.Ref : 327RefKind.None; 377public override RefKind RefKind 636if (RefKind != RefKind.None &&

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

666public override RefKind RefKind => Signature.ReturnParam.RefKind; 1134case RefKind.None: 1135case RefKind.Ref: 1136case RefKind.In: 1137case RefKind.RefReadOnlyParameter: 1161foreach (var kind in this.ParameterRefKinds) 1165case RefKind.None: 1166case RefKind.In: 1168case RefKind.Out: 1169case RefKind.Ref: 1170case RefKind.RefReadOnlyParameter:

Symbols\Metadata\PE\PEParameterSymbol.cs (20)

73public RefKind RefKind 75get { return (RefKind)((_bits >> RefKindOffset) & RefKindMask); } 98Debug.Assert(EnumUtilities.ContainsAllValues<RefKind>(RefKindMask)); 104public PackedFlags(RefKind refKind, bool attributesAreComplete, bool hasNameInMetadata, ScopedKind scope, bool hasUnscopedRefAttribute) 258RefKind refKind = RefKind.None; 264refKind = isByRef ? RefKind.Ref : RefKind.None; 292refKind = RefKind.Out; 296refKind = RefKind.RefReadOnlyParameter; 300refKind = RefKind.In; 304refKind = RefKind.Ref; 333Debug.Assert(refKind != RefKind.None); 419Debug.Assert(parameter.RefKind != RefKind.RefReadOnlyParameter); 420isBad |= (parameter.RefKind == RefKind.RefReadOnly) != hasInAttributeModifier; 422else if (parameter.RefKind is RefKind.In or RefKind.RefReadOnlyParameter) 469public override RefKind RefKind 1117bool filterIsReadOnlyAttribute = this.RefKind == RefKind.In; 1118bool filterRequiresLocationAttribute = this.RefKind == RefKind.RefReadOnlyParameter;

Symbols\Metadata\PE\PEPropertySymbol.cs (8)

34private readonly RefKind _refKind; 210var isBad = (result.RefKind == RefKind.In) != result.RefCustomModifiers.HasInAttributeModifier(); 281_refKind = RefKind.RefReadOnly; 285_refKind = RefKind.Ref; 290_refKind = RefKind.None; 376if (this.RefKind != RefKind.None && _setMethod != null) 680public override RefKind RefKind 739this.RefKind == RefKind.RefReadOnly ? AttributeDescription.IsReadOnlyAttribute : default,

Symbols\MethodSymbol.cs (5)

220return this.RefKind == RefKind.Ref; 231Debug.Assert(this.RefKind != RefKind.Out); 232return this.RefKind == RefKind.RefReadOnly; 239public abstract RefKind RefKind { get; } 921internal ImmutableArray<RefKind> ParameterRefKinds

Symbols\NamedTypeSymbol.cs (3)

398if (thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) 403if (thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter

Symbols\ParameterSignature.cs (10)

19internal readonly ImmutableArray<RefKind> parameterRefKinds; 22new ParameterSignature(ImmutableArray<TypeWithAnnotations>.Empty, default(ImmutableArray<RefKind>)); 25ImmutableArray<RefKind> parameterRefKinds) 39ArrayBuilder<RefKind> refs = null; 46var refKind = parameter.RefKind; 49if (refKind != RefKind.None) 51refs = ArrayBuilder<RefKind>.GetInstance(parm, RefKind.None); 61ImmutableArray<RefKind> refKinds = refs != null ? refs.ToImmutableAndFree() : default(ImmutableArray<RefKind>);

Symbols\ParameterSymbol.cs (7)

59public abstract RefKind RefKind { get; } 165RefKind refKind; 167((refKind = RefKind) == RefKind.None || 168(refKind is RefKind.In or RefKind.RefReadOnlyParameter) || 169(refKind == RefKind.Ref && ContainingSymbol.ContainingType.IsComImport)); 473RefKind IParameterSymbolInternal.RefKind => RefKind;

Symbols\PropertySymbol.cs (4)

71public bool ReturnsByRef { get { return this.RefKind == RefKind.Ref; } } 76public bool ReturnsByRefReadonly { get { return this.RefKind == RefKind.RefReadOnly; } } 81public abstract RefKind RefKind { get; } 126internal ImmutableArray<RefKind> ParameterRefKinds

Symbols\PropertySymbolExtensions.cs (2)

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

Symbols\PublicModel\FieldSymbol.cs (1)

34RefKind IFieldSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\LocalSymbol.cs (1)

52RefKind ILocalSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\MethodSymbol.cs (1)

341RefKind IMethodSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\ParameterSymbol.cs (1)

59RefKind IParameterSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\PropertySymbol.cs (1)

110RefKind IPropertySymbol.RefKind => _underlying.RefKind;

Symbols\ReducedExtensionMethodSymbol.cs (3)

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

Symbols\RefKindExtensions.cs (14)

14public static bool IsManagedReference(this RefKind refKind) 16Debug.Assert(refKind <= RefKind.RefReadOnly); 18return refKind != RefKind.None; 21public static RefKind GetRefKind(this SyntaxKind syntaxKind) 26return RefKind.Ref; 28return RefKind.Out; 30return RefKind.In; 32return RefKind.None; 38public static bool IsWritableReference(this RefKind refKind) 42case RefKind.Ref: 43case RefKind.Out: 45case RefKind.None: 46case RefKind.In: 47case RefKind.RefReadOnlyParameter:

Symbols\Retargeting\RetargetingFieldSymbol.cs (1)

73public override RefKind RefKind => _underlyingField.RefKind;

Symbols\SignatureOnlyMethodSymbol.cs (3)

27private readonly RefKind _refKind; 41RefKind refKind, 75public override RefKind RefKind { get { return _refKind; } }

Symbols\SignatureOnlyParameterSymbol.cs (3)

21private readonly RefKind _refKind; 28RefKind refKind) 50public override RefKind RefKind { get { return _refKind; } }

Symbols\SignatureOnlyPropertySymbol.cs (3)

24private readonly RefKind _refKind; 34RefKind refKind, 50public override RefKind RefKind { get { return _refKind; } }

Symbols\Source\CustomModifierUtils.cs (4)

43destinationMethod.RefKind != RefKind.None ? constructedSourceMethod.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 73const RefKind refKind = RefKind.None; 146destinationParameter.RefKind != RefKind.None ? sourceParameter.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty,

Symbols\Source\FieldSymbolWithAttributesAndModifiers.cs (1)

394if (this.RefKind == RefKind.RefReadOnly)

Symbols\Source\GlobalExpressionVariable.cs (2)

69public sealed override RefKind RefKind => RefKind.None;

Symbols\Source\LambdaParameterSymbol.cs (1)

23RefKind refKind,

Symbols\Source\LambdaSymbol.cs (8)

23private RefKind _refKind; 49ImmutableArray<RefKind> parameterRefKinds, 50RefKind refKind, 149public override RefKind RefKind 168internal void SetInferredReturnType(RefKind refKind, TypeWithAnnotations inferredReturnType) 172Debug.Assert(refKind != RefKind.RefReadOnly); 331ImmutableArray<RefKind> parameterRefKinds) 354var refKind = unboundLambda.RefKind(p);

Symbols\Source\LocalFunctionSymbol.cs (5)

23private readonly RefKind _refKind; 244public override RefKind RefKind => _refKind; 268if (_refKind == RefKind.RefReadOnly) 294Debug.Assert(_refKind == RefKind.None 358(_refKind == RefKind.RefReadOnly && DeclaringCompilation is { } compilation) ?

Symbols\Source\ParameterHelpers.cs (36)

Symbols\Source\SourceAssemblySymbol.cs (1)

2744else if (field.RefKind != RefKind.None)

Symbols\Source\SourceClonedParameterSymbol.cs (1)

97public override RefKind RefKind

Symbols\Source\SourceComplexParameterSymbol.cs (10)

46RefKind refKind, 910return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 935if (this.RefKind == RefKind.RefReadOnlyParameter && this.IsOptional && this.ParameterSyntax.Default is null) 1464case RefKind.Ref: 1471case RefKind.Out: 1478case RefKind.In: 1485case RefKind.RefReadOnlyParameter: 1763RefKind refKind, 1789RefKind refKind, 1805Debug.Assert(refKind != RefKind.None || _refCustomModifiers.IsEmpty);

Symbols\Source\SourceConstructorSymbol.cs (1)

112methodKind, RefKind.None, declarationModifiers, returnsVoid: true, returnsVoidIsSet: true, hasAnyBody: hasAnyBody,

Symbols\Source\SourceDelegateMethodSymbol.cs (13)

28RefKind refKind, 56returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind); 218: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 221SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 222SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 260RefKind refKind, 283if (this.RefKind == RefKind.RefReadOnly) 322if (this.RefKind == RefKind.RefReadOnly) 358: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 368parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 369parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 407if (p.RefKind != RefKind.None) 414parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));

Symbols\Source\SourceDestructorSymbol.cs (1)

69MethodKind.Destructor, RefKind.None, declarationModifiers, returnsVoid: true, returnsVoidIsSet: true,

Symbols\Source\SourceEnumConstantSymbol.cs (2)

59public sealed override RefKind RefKind => RefKind.None;

Symbols\Source\SourceEventAccessorSymbol.cs (1)

37RefKind.None,

Symbols\Source\SourceFieldSymbol.cs (1)

139if (RefKind == RefKind.RefReadOnly)

Symbols\Source\SourceLocalSymbol.cs (3)

33private readonly RefKind _refKind; 100_scope = _refKind != RefKind.None 578public override RefKind RefKind

Symbols\Source\SourceMemberContainerSymbol.cs (18)

2237var refKind1 = method1.Parameters[i].RefKind; 2238var refKind2 = method2.Parameters[i].RefKind; 4473if (methodParam.RefKind != RefKind.None) 4496methodParams[0].RefKind == RefKind.None && 4889RefKind.Out 4891RefKind.None, 4937RefKind.None 4939RefKind.None, 4990RefKind.None)), 4991RefKind.None, 5046RefKind.None, 5125RefKind.None, 5220RefKind.None, 5251RefKind.None, 5317RefKind.None 5319RefKind.None, 5518_ = fieldSyntax.Declaration.Type.SkipScoped(out _).SkipRefInField(out var refKind); 5525var modifiers = SourceMemberFieldSymbol.MakeModifiers(this, fieldSyntax.Declaration.Variables[0].Identifier, fieldSyntax.Modifiers, isRefField: refKind != RefKind.None, diagnostics, out modifierErrors);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (19)

1298overrideMethod.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.Out, 1364RefKind refKind, 1370case RefKind.Ref: 1376case RefKind.Out: 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()) || 1424(method.RefKind is RefKind.Ref or RefKind.RefReadOnly)) 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()))

Symbols\Source\SourceMemberFieldSymbol.cs (13)

337internal readonly RefKind RefKind; 340internal TypeAndRefKind(RefKind refKind, TypeWithAnnotations type) 432public sealed override RefKind RefKind => GetTypeAndRefKind(ConsList<FieldSymbol>.Empty).RefKind; 462RefKind refKind = RefKind.None; 500Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 502if (refKind != RefKind.None) 518type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRefInField(out RefKind refKindToAssert), diagnostics, out isVar); 519Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error 550var initializerOpt = executableBinder.BindInferredVariableInitializer(diagnostics, RefKind.None, syntaxNode, declarator); 579if (refKind != RefKind.None)

Symbols\Source\SourceMemberMethodSymbol.cs (7)

131public RefKind RefKind 133get { return (RefKind)((_flags >> RefKindOffset) & RefKindMask); } 177Debug.Assert(EnumUtilities.ContainsAllValues<RefKind>(RefKindMask)); 189RefKind refKind, 235RefKind refKind, 423RefKind refKind, 1083public sealed override RefKind RefKind => this.flags.RefKind;

Symbols\Source\SourceMethodSymbol.cs (1)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)

779if (param.RefKind == RefKind.Out) 1413static void checkAndReportManagedTypes(TypeSymbol type, RefKind refKind, SyntaxNode syntax, bool isParam, BindingDiagnosticBag diagnostics) 1415if (refKind != RefKind.None) 1538if (this.RefKind != RefKind.None)

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (9)

316if (signature.RefKind != RefKind.None) 334if (parameter.RefKind != RefKind.None) 748static void appendRefKind(RefKind refKind, StringBuilder builder, bool forParameter = false) 752RefKind.None => "", 753RefKind.Ref => "ref ", 754RefKind.Out => "out ", 755RefKind.In when forParameter => "in ", 756RefKind.RefReadOnly => "ref readonly ", 757RefKind.RefReadOnlyParameter => "ref readonly ",

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

118else if (RefKind == RefKind.RefReadOnly) 242if (RefKind == RefKind.RefReadOnly)

Symbols\Source\SourceOrdinaryMethodSymbol.cs (6)

155Debug.Assert(this.RefKind == RefKind.None || !returnType.IsVoidType() || returnTypeSyntax.HasErrors); 212var parameter0RefKind = this.Parameters[0].RefKind; 221else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType) 225else if (parameter0RefKind is RefKind.In or RefKind.RefReadOnlyParameter 865else if (IsPartial && !HasExplicitAccessModifier && Parameters.Any(static p => p.RefKind == RefKind.Out))

Symbols\Source\SourceParameterSymbol.cs (7)

26private readonly RefKind _refKind; 35RefKind refKind, 105RefKind refKind, 215public sealed override RefKind RefKind 295internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 297internal override bool IsMetadataOut => RefKind == RefKind.Out;

Symbols\Source\SourceParameterSymbolBase.cs (2)

121case RefKind.In: 124case RefKind.RefReadOnlyParameter:

Symbols\Source\SourcePropertySymbolBase.cs (10)

59private readonly RefKind _refKind; 98RefKind refKind, 251_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 270else if (_refKind == RefKind.RefReadOnly) 359public sealed override RefKind RefKind 881if (RefKind != RefKind.None && IsRequired) 905if (this.RefKind != RefKind.None) 942if (_refKind != RefKind.None) 969else if (RefKind != RefKind.None) 1041if (_refKind == RefKind.RefReadOnly)

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

24RefKind refKind, 36RefKind refKind,

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (8)

41methodKind, RefKind.None, declarationModifiers, 401case RefKind.Out: // 'out' is disallowed in general 402case RefKind.Ref: // 'ref' receivers are disallowed for types not known to be a struct 405case RefKind.In: 406case RefKind.RefReadOnlyParameter: 415case RefKind.None: 473if (p.RefKind != RefKind.None && p.RefKind != RefKind.In)

Symbols\Source\ThisParameterSymbol.cs (5)

153public override RefKind RefKind 159return RefKind.None; 164return RefKind.Out; 169return RefKind.In; 172return RefKind.Ref;

Symbols\SubstitutedFieldSymbol.cs (1)

106public override RefKind RefKind => _underlyingField.RefKind;

Symbols\SymbolExtensions.cs (4)

475internal static void GetTypeOrReturnType(this Symbol symbol, out RefKind refKind, out TypeWithAnnotations returnType, 482refKind = RefKind.None; 500refKind = RefKind.None; 517refKind = RefKind.None;

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

15SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, parameterName));

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

15SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, "item"));

Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (2)

33public override RefKind RefKind => RefKind.None;

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

44RefKind.None,

Symbols\Synthesized\Records\SynthesizedPrimaryConstructorParameterBackingFieldSymbol.cs (2)

48public override RefKind RefKind => RefKind.None;

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

33ordinal: 0, RefKind.None, "other", Locations)));

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

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

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

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

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

41RefKind.Out,

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

41RefKind.None,

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

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

Symbols\Synthesized\Records\SynthesizedRecordEqualityOperatorBase.cs (2)

75ordinal: 0, RefKind.None, "left", Locations), 78ordinal: 1, RefKind.None, "right", Locations)));

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

41ordinal: 0, RefKind.None, "other", Locations)));

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

37ordinal: 0, RefKind.None, "obj", Locations)));

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

17MethodKind.Ordinary, RefKind.None, declarationModifiers, returnsVoid: false, returnsVoidIsSet: false,

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

98ordinal: 0, RefKind.None, "builder", Locations)));

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

40RefKind.None,

Symbols\Synthesized\RefKindVector.cs (11)

39internal RefKind this[int index] 46(false, false, false) => RefKind.None, 47(false, false, true) => RefKind.Ref, 48(false, true, false) => RefKind.Out, 49(false, true, true) => RefKind.RefReadOnly, 50(true, false, false) => RefKind.RefReadOnlyParameter, 59RefKind.None => (false, false, false), 60RefKind.Ref => (false, false, true), 61RefKind.Out => (false, true, false), 62RefKind.RefReadOnly => (false, true, true), 63RefKind.RefReadOnlyParameter => (true, false, false),

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

24: base(accessor, ordinal, RefKind.None, ParameterSymbol.ValueParameterName, accessor.TryGetFirstLocation(),

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (4)

96Debug.Assert(property.RefKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 122public override RefKind RefKind => _property.RefKind;

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (7)

21SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(objectType), 0, RefKind.None, "object"), 22SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intPtrType), 1, RefKind.None, "method")); 35internal ParameterDescription(TypeWithAnnotations type, RefKind refKind, ScopedKind scope, ConstantValue? defaultValue, bool isParams, bool hasUnscopedRefAttribute) 46internal readonly RefKind RefKind; 59RefKind refKind) 68RefCustomModifiers = refKind == RefKind.RefReadOnly ? 166public override RefKind RefKind { get; }

Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (5)

43return [SynthesizedParameterSymbol.Create(ctor, TypeWithAnnotations.Create(systemStringType), ordinal: 0, RefKind.None, name: "name")]; 99public override RefKind RefKind => RefKind.None; 167public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)

53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, boolArrayType, 0, RefKind.None)),

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (2)

53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, annotatedByteType, 0, RefKind.None)), 57m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, byteArrayType, 0, RefKind.None)),

Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)

41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemByteType), 0, RefKind.None)),

Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)

41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemBooleanType), 0, RefKind.None)),

Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)

39m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(int32Type), 0, RefKind.None)),

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (11)

115public override RefKind RefKind 117get { return RefKind.None; } 302default(ImmutableArray<RefKind>), 368argumentRefKindsOpt: default(ImmutableArray<RefKind>), 394argumentRefKindsOpt: default(ImmutableArray<RefKind>), 447refKind: RefKind.None, 465refKind: RefKind.None, 559RefKind.None, 578TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 629argumentRefKindsOpt: default(ImmutableArray<RefKind>), 650RefKind.None,

Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (2)

29public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedFieldSymbol.cs (2)

36public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (2)

206public override RefKind RefKind 208get { return RefKind.None; }

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (3)

19SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(stringType), ordinal: 0, RefKind.None), 20SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), ordinal: 1, RefKind.None) 58delegateInvoke.GetParameters() is not [{ RefKind: RefKind.None } parameter] ||

Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)

96public sealed override RefKind RefKind

Symbols\Synthesized\SynthesizedInlineArrayAsReadOnlySpanMethod.cs (2)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.In, "buffer"), 18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "length")));

Symbols\Synthesized\SynthesizedInlineArrayAsSpanMethod.cs (2)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"), 18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "length")));

Symbols\Synthesized\SynthesizedInlineArrayElementRefMethod.cs (4)

17this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"), 18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "index"))); 21public override RefKind RefKind => RefKind.Ref;

Symbols\Synthesized\SynthesizedInlineArrayElementRefReadOnlyMethod.cs (4)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefMethod.cs (3)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefReadOnlyMethod.cs (3)

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

149public override RefKind RefKind 151get { return RefKind.None; }

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (2)

114public override RefKind RefKind 116get { return RefKind.None; }

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (6)

217public override RefKind RefKind 221return RefKind.None; 471) : base(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, ScopedKind.None, name) 475internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 477internal override bool IsMetadataOut => RefKind == RefKind.Out;

Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (2)

36public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedLocal.cs (5)

27private readonly RefKind _refKind; 41RefKind refKind = RefKind.None 51Debug.Assert(refKind != RefKind.Out); 98public sealed override RefKind RefKind

Symbols\Synthesized\SynthesizedParameterSymbol.cs (14)

22private readonly RefKind _refKind; 29RefKind refKind, 47public override RefKind RefKind => _refKind; 184case RefKind.In: 187case RefKind.RefReadOnlyParameter: 244RefKind refKind, 251internal sealed override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 253internal sealed override bool IsMetadataOut => RefKind == RefKind.Out; 261RefKind refKind, 352RefKind refKind, 413internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter || _baseParameterForAttributes?.IsMetadataIn == true; 415internal override bool IsMetadataOut => RefKind == RefKind.Out || _baseParameterForAttributes?.IsMetadataOut == true;

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

181public override RefKind RefKind

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (2)

59TypeWithAnnotations.Create(Binder.GetSpecialType(compilation, SpecialType.System_String, NoLocation.Singleton, diagnostics)))), 0, RefKind.None, "args")); 73RefKind.None,

Symbols\Synthesized\SynthesizedStaticConstructor.cs (2)

127public override RefKind RefKind 131return RefKind.None;

Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)

21this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s"))); 31this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s")));

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)

29SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

19this.SetParameters(ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "unmatchedValue")));

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

113public override RefKind RefKind

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

157public override RefKind RefKind => RefKind.None;

Symbols\Tuples\TupleFieldSymbol.cs (1)

125public sealed override RefKind RefKind => _underlyingField.RefKind;

Symbols\TypeSymbol.cs (3)

2008RefKind interfaceMemberRefKind = RefKind.None; 2568return elementField is { RefKind: RefKind.None, IsFixedSizeBuffer: false };

Symbols\UpdatedContainingSymbolLocal.cs (1)

79public override RefKind RefKind => _underlyingLocal.RefKind;

Symbols\VarianceSafety.cs (3)

166requireInputSafety: method.RefKind != RefKind.None, 202requireInputSafety: hasSetter || !(property.GetMethod?.RefKind == RefKind.None), 245requireOutputSafety: param.RefKind != RefKind.None,

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

58public override RefKind RefKind

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

44public sealed override RefKind RefKind

Symbols\Wrapped\WrappedPropertySymbol.cs (1)

49public override RefKind RefKind

Syntax\SyntaxNodeExtensions.cs (11)

222internal static RefKind GetRefKindInLocalOrReturn(this TypeSyntax syntax, BindingDiagnosticBag diagnostics) 224syntax.SkipRefInLocalOrReturn(diagnostics, out var refKind); 238internal static TypeSyntax SkipRefInField(this TypeSyntax syntax, out RefKind refKind) 245internal static TypeSyntax SkipRefInLocalOrReturn(this TypeSyntax syntax, BindingDiagnosticBag? diagnostics, out RefKind refKind) 248private static TypeSyntax SkipRefWorker(TypeSyntax syntax, BindingDiagnosticBag? diagnostics, out RefKind refKind) 254? RefKind.RefReadOnly 255: RefKind.Ref; 283refKind = RefKind.None; 320out RefKind refKind) 324refKind = RefKind.None; 330refKind = RefKind.Ref;