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)

1447argumentRefKinds = argumentRefKinds.Add(RefKind.None); 1568if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 2122parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds); 3600{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 3644RefKind sourceRefKind, RefKind destinationRefKind, bool checkingReturns, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 3649: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 3654if (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()) 2122if (parameter.RefKind != RefKind.None) 2142(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2145if (parameter.RefKind != RefKind.None) 2159else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } && 2312if (localSymbol.RefKind == RefKind.None && type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2618if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3172RefKind origRefKind = argumentSyntax.RefOrOutKeyword.Kind().GetRefKind(); 3176RefKind refKind = origRefKind == RefKind.None || RefMustBeObeyed(isDelegateCreation, argumentSyntax) ? origRefKind : RefKind.None; 3189if (!hadError && isDelegateCreation && origRefKind != RefKind.None && result.Arguments.Count == 1) 3196var requiredValueKind = origRefKind == RefKind.In ? BindValueKind.ReadonlyRef : BindValueKind.RefOrOut; 3208private BoundExpression BindArgumentValue(BindingDiagnosticBag diagnostics, ArgumentSyntax argumentSyntax, bool allowArglist, RefKind refKind) 3409RefKind refKind) 3417if (refKind != RefKind.None) 3427result.RefKinds.Add(RefKind.None); 3475private BoundExpression BindArgumentExpression(BindingDiagnosticBag diagnostics, ExpressionSyntax argumentExpression, RefKind refKind, bool allowArglist) 3478refKind == RefKind.None ? 3480refKind == RefKind.In ? 3851var argumentRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(handlerArgumentIndexes.Length); 3861RefKind refKind; 3867refKind = RefKind.None; 3953argumentRefKindsBuilder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 3977private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter, 3989if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 4001if (argRefKind == RefKind.Ref) 4003if (parameter.RefKind == RefKind.In) 4013else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 5120if (analyzedArguments.RefKind(i) is (RefKind.Ref or RefKind.Out)) 5719ArrayBuilder<RefKind> refKinds, 5892var rhsExpr = initializer.Right.CheckAndUnwrapRefExpression(diagnostics, out RefKind refKind); 5893bool isRef = refKind == RefKind.Ref; 6064ImmutableArray<RefKind> argumentRefKindsOpt = default; 8597extensionMethodArguments.RefKinds.Add(RefKind.None); 8748RefKind returnRefKind, 8832RefKind returnRefKind, 8950RefKind returnRefKind, 9213fieldSymbol.RefKind != RefKind.None) 10218RefKind refKind = analyzedArguments.RefKind(i); 10219if (refKind != RefKind.None) 10318default(ImmutableArray<RefKind>), 10436ImmutableArray<RefKind> argumentRefKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 10689original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10790original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10791original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 10854getMethod.RefKind == RefKind.None && 10898RefKind returnRefKind = default, 10922RefKind returnRefKind = default, 10954RefKind returnRefKind = default, 11025RefKind returnRefKind = default, 11491RefKind? returnRefKindOverride = null, 11498var returnRefKind = returnRefKindOverride ?? methodSymbol.RefKind; 11516if (returnsVoid && returnRefKind != RefKind.None) 11530returnRefKind == RefKind.None && 11532(parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)) && 11566parameterRefKinds.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); 1373CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1375if (extensionParameter.RefKind == RefKind.Ref) 1534ArrayBuilder<RefKind>? argumentRefKindsBuilder, 1619argumentRefKindsBuilder.Add(RefKind.None); 1644argumentRefKindsBuilder.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)

449analyzedArguments.RefKinds.Add(RefKind.Ref); 450analyzedArguments.RefKinds.Add(RefKind.None); 3559analyzedArguments.RefKinds.Add(RefKind.Ref); 3861(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3925if (!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3926(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4267if (parameterSymbol.RefKind != RefKind.None) 4298return localSymbol.RefKind != RefKind.None; 5950var whenTrue = node.WhenTrue.CheckAndUnwrapRefExpression(diagnostics, out var whenTrueRefKind); 5951var whenFalse = node.WhenFalse.CheckAndUnwrapRefExpression(diagnostics, out var whenFalseRefKind); 5953var isRef = whenTrueRefKind == RefKind.Ref && whenFalseRefKind == RefKind.Ref; 5956if (whenFalseRefKind == RefKind.Ref) 5961if (whenTrueRefKind == RefKind.Ref)

Binder\Binder_Patterns.cs (4)

98RefKind: RefKind.None, 216RefKind: RefKind.None, 369RefKind: RefKind.None, 370Parameters: [{ RefKind: RefKind.Out }],

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: 486if (elementConversionClassification.Kind != ConversionKind.Identity && IterationVariable.RefKind is RefKind.Ref or RefKind.RefReadOnly) 889builder.CurrentPropertyGetter?.RefKind == (wellKnownSpan == WellKnownType.System_ReadOnlySpan_T ? RefKind.RefReadOnly : RefKind.Ref)) || 1216patternDisposeMethod.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)

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

Binder\RefSafetyAnalysis.cs (5)

554Debug.Assert(localSymbol.RefKind == RefKind.None || 568if (localSymbol.RefKind != RefKind.None) 585ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1266ImmutableArray<RefKind> refKinds; 1287AddLocalScopes(local, refEscapeScope: local.RefKind == RefKind.None ? _localScopeDepth : collectionEscape, valEscapeScope: collectionEscape);

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

1500if (anonymousFunction.HasExplicitReturnType(out var refKind, refCustomModifiers: out _, out var returnType)) 1584if (delegateParameters[p].RefKind == RefKind.Out) 3435bool hasConversion(RefKind refKind, TypeWithAnnotations sourceType, TypeWithAnnotations destinationType, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 3439case 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\BoundDagEvaluation.cs (2)

327Debug.Assert(parameter.RefKind == RefKind.Out); 339Debug.Assert(parameter.RefKind == RefKind.Out);

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)) 823var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 847refKind == CodeAnalysis.RefKind.None && 869if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly) 936ImmutableArray<RefKind> parameterRefKinds, 937RefKind refKind, 953var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 986ImmutableArray<RefKind> parameterRefKinds) 988bool hasExplicitReturnType = HasExplicitReturnType(out var refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out var returnType); 1016Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1042Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1052ImmutableArray<RefKind> parameterRefKinds, 1054RefKind refKind, 1091public readonly ImmutableArray<RefKind> ParameterRefKinds; 1094public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null); 1096private ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations> parameterTypes, ImmutableArray<RefKind> parameterRefKinds, NamedTypeSymbol? taskLikeReturnTypeOpt) 1157out ImmutableArray<RefKind> parameterRefKinds, 1163parameterRefKinds = ImmutableArray<RefKind>.Empty; 1172var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameterCount); 1248?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty)); 1265ImmutableArray<RefKind> parameterRefKinds) 1268var refKind = inferredReturnType.RefKind; 1282refKind = CodeAnalysis.RefKind.None; 1496private readonly RefKind _returnRefKind; 1503private readonly ImmutableArray<RefKind> _parameterRefKinds; 1512RefKind returnRefKind, 1519ImmutableArray<RefKind> parameterRefKinds, 1545public override bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 1606public override RefKind RefKind(int index) 1609return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1643statements[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) && 2221var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2250left.LocalSymbol.RefKind == RefKind.Ref && 2487public override RefKind RefKind 2489get { return RefKind.None; }

Compilation\CSharpCompilation.cs (5)

2329if (method.RefKind != RefKind.None) 4253RefKind returnRefKind, 4255ImmutableArray<RefKind> parameterRefKinds, 4288if (returnRefKind == RefKind.Out) 4428fields.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)

248if (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)

1132VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), null, default, false); 1293VisitRvalue(node.InitializerOpt, isKnownToBeAnLvalue: node.LocalSymbol.RefKind != RefKind.None); 1296if (node.LocalSymbol.RefKind != RefKind.None) 1437WriteArgument(receiverOpt, RefKind.Ref, method: null); 1443var thisRefKind = thisParameter.RefKind; 1517protected virtual void VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1524private void VisitArgumentsBeforeCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt) 1529RefKind refKind = GetRefKind(refKindsOpt, i); 1530if (refKind != RefKind.Out) 1532VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1545private void VisitArgumentsAfterCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol? method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1549RefKind refKind = GetRefKind(refKindsOpt, i); 1552case RefKind.None: 1553case RefKind.In: 1554case RefKind.RefReadOnlyParameter: 1557case RefKind.Ref: 1560goto case RefKind.Out; 1563case RefKind.Out: 1574protected static RefKind GetRefKind(ImmutableArray<RefKind> refKindsOpt, int index) 1576return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index]; 1579protected virtual void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2033VisitRvalue(node.ExpressionOpt, isKnownToBeAnLvalue: node.RefKind != RefKind.None); 2036if (node.RefKind != RefKind.None) 2147if (property.RefKind == RefKind.None) 2165var refKind = node.Left.Kind == BoundKind.BadExpression 2166? RefKind.Ref 2202if (property.RefKind == RefKind.None) 2221if (property.RefKind == RefKind.None) 2838if (property.RefKind == RefKind.None) 3340WriteArgument(operand, RefKind.Ref, method: null); 3526this.WriteArgument(operand, RefKind.Out, null); //Out because we know it will definitely be assigned. 3567VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.Constructor, default, false); 3651VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3657VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3665VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), method: null, default, false); 3757property.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); 924write: field.RefKind == RefKind.None || isRef); 1187((ParameterSymbol)symbol).RefKind == RefKind.Out) 1287if (fieldSymbol.RefKind != RefKind.None) 1471if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess) 1524if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 1575if (isRef && param.RefKind == RefKind.Out) 1593write: field.RefKind == RefKind.None || isRef); 1767if (parameter.RefKind != RefKind.Out) 1779if (thisParameter.RefKind != RefKind.Out) 1791if (extensionParameter.RefKind != RefKind.Out) 1814if (current is not MethodSymbol && parameter.RefKind == RefKind.Out) 1844if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async 1852NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1910if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor) 1922if (parameter.RefKind != RefKind.None) 2524protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2526if (refKind == RefKind.Ref) 2540if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2732NoteWrite(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 (71)

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 (3)

70if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None }) 308refKinds: ImmutableArray<RefKind>.Empty, 415Debug.Assert(thisParameter is not { Type.IsValueType: true, RefKind: RefKind.Ref });

Lowering\ClosureConversion\ClosureConversion.cs (7)

577new BoundReturnStatement(syntax, RefKind.None, null, @checked: false)); 889ref ImmutableArray<RefKind> argRefKinds) 930var refkindsBuilder = ArrayBuilder<RefKind>.GetInstance(argumentsBuilder.Count); 937refkindsBuilder.AddMany(RefKind.None, arguments.Length); 940refkindsBuilder.AddMany(RefKind.Ref, frameCount); 1354var argRefKinds = default(ImmutableArray<RefKind>); 1381ImmutableArray<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)

310ImmutableArray<RefKind> argumentRefKindsOpt, 358else if (method.RefKind != RefKind.None) 555VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray<RefKind>), default(ImmutableArray<string>), default(ImmutableArray<int>), node.DefaultArguments, node); 579if (_inExpressionLambda && property.RefKind != RefKind.None) 621if (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)

309if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 455Debug.Assert(parameter.RefKind == RefKind.None); 557ImmutableArray<RefKind> argumentRefKindsOpt = NullableWalker.AdjustArgumentRefKindsIfNeeded(original.ArgumentRefKindsOpt, adjustForExtensionBlockMethod, method, arguments.Length); 574private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds) 600if (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)

1102return ((BoundCall)expr).Method.RefKind != RefKind.None; 1105return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1108return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None; 1143symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

163var refKindBuilder = ArrayBuilder<RefKind>.GetInstance(); 166void addArg(RefKind refKind, BoundExpression expression) 188addArg(RefKind.Out, _tempAllocator.GetTemp(outputTemp)); 555&& 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)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (11)

55ImmutableArray<RefKind> refKinds) 108ImmutableArray<RefKind> argumentRefKindsOpt, 119if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 330possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref); 511Debug.Assert(!isLeftOfAssignment || node.IndexerOrSliceAccess.GetRefKind() == RefKind.Ref); 568receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 633if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 871receiver.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)

270if (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]; 904expression = Spill(leftBuilder, expression, RefKind.None); 919left = Spill(leftBuilder, VisitExpression(ref leftBuilder, left), RefKind.Ref); 951expression = Spill(leftBuilder, expression, RefKind.None); 966receiver = Spill(leftBuilder, VisitExpression(ref leftBuilder, field.ReceiverOpt), RefKind.Ref); 1046RefKind refKind = ReceiverSpillRefKind(receiver); 1048Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1052if (refKind != RefKind.None && 1085private static RefKind ReceiverSpillRefKind(BoundExpression receiver) 1087var result = RefKind.None; 1090result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1279var receiverRefKind = ReceiverSpillRefKind(node.Receiver); 1300if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1303receiver = Spill(receiverBuilder, receiver, RefKind.None); 1318receiver = Spill(receiverBuilder, receiver, RefKind.Ref); 1320var 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)

175if (local.RefKind != RefKind.None) 183Debug.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)

580Debug.Assert(CurrentFunction.RefKind == RefKind.None); 585return new BoundReturnStatement(Syntax, CurrentFunction.RefKind != RefKind.None ? RefKind.Ref : RefKind.None, expression, @checked: false) { WasCompilerGenerated = true }; 605RefKind refKind = RefKind.None, 645return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 783public BoundObjectCreationExpression New(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKinds) 893public static ImmutableArray<RefKind> ArgumentRefKindsFromParameterRefKinds(MethodSymbol method, bool useStrictArgumentRefKinds) 897if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 898(useStrictArgumentRefKinds && result.Contains(RefKind.In)))) 900var builder = ArrayBuilder<RefKind>.GetInstance(result.Length); 902foreach (var refKind in result) 913public static RefKind ArgumentRefKindFromParameterRefKind(RefKind refKind, bool useStrictArgumentRefKinds) 917RefKind.In or RefKind.RefReadOnlyParameter when useStrictArgumentRefKinds => RefKindExtensions.StrictIn, 918RefKind.RefReadOnlyParameter => RefKind.In, 923public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1652RefKind refKind = RefKind.None, 1669case RefKind.Out: 1670refKind = RefKind.Ref; 1673case RefKind.In: 1682Debug.Assert(argument.GetRefKind() != RefKind.In); 1683refKind = RefKind.None; 1687case RefKind.None: 1688case RefKind.Ref: 1719isRef: 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)

817internal SynthesizedAttributeData? SynthesizeDynamicAttribute(TypeSymbol type, int customModifiersCount, RefKind refKindOpt = RefKind.None) 822if (type.IsDynamic() && refKindOpt == RefKind.None && customModifiersCount == 0) 931internal static ImmutableArray<TypedConstant> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount, TypeSymbol booleanType) 943internal static ImmutableArray<bool> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount) 950internal static ImmutableArray<bool> EncodeWithoutCustomModifierFlags(TypeSymbol type, RefKind refKind) 957internal static void Encode(TypeSymbol type, int customModifiersCount, RefKind refKind, ArrayBuilder<bool> transformFlagsBuilder, bool addCustomModifierFlags) 961if (refKind != RefKind.None) 1052void handle(RefKind refKind, ImmutableArray<CustomModifier> customModifiers, TypeWithAnnotations twa) 1059if (refKind != RefKind.None) 1214return parameter.RefKind != RefKind.None; 1219return method.RefKind != RefKind.None; 1224return 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)

92public void SetRefKind(RefKind refKind) 99public RefKind RefKind => (RefKind)((_bits >> RefKindOffset) & RefKindMask); 347RefKind refKind = fieldInfo.IsByRef ? 348moduleSymbol.Module.HasIsReadOnlyAttribute(_handle) ? RefKind.RefReadOnly : RefKind.Ref : 349RefKind.None; 399public override RefKind RefKind 687if (RefKind != RefKind.None &&

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

684public override RefKind RefKind => Signature.ReturnParam.RefKind; 1161case RefKind.None: 1162case RefKind.Ref: 1163case RefKind.In: 1164case RefKind.RefReadOnlyParameter: 1188foreach (var kind in this.ParameterRefKinds) 1192case RefKind.None: 1193case RefKind.In: 1195case RefKind.Out: 1196case RefKind.Ref: 1197case RefKind.RefReadOnlyParameter:

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

74public RefKind RefKind 76get { return (RefKind)((_bits >> RefKindOffset) & RefKindMask); } 99Debug.Assert(EnumUtilities.ContainsAllValues<RefKind>(RefKindMask)); 105public PackedFlags(RefKind refKind, bool attributesAreComplete, bool hasNameInMetadata, ScopedKind scope, bool hasUnscopedRefAttribute) 259RefKind refKind = RefKind.None; 265refKind = isByRef ? RefKind.Ref : RefKind.None; 293refKind = RefKind.Out; 297refKind = RefKind.RefReadOnlyParameter; 301refKind = RefKind.In; 305refKind = RefKind.Ref; 334Debug.Assert(refKind != RefKind.None); 420Debug.Assert(parameter.RefKind != RefKind.RefReadOnlyParameter); 421isBad |= (parameter.RefKind == RefKind.RefReadOnly) != hasInAttributeModifier; 423else if (parameter.RefKind is RefKind.In or RefKind.RefReadOnlyParameter) 470public override RefKind RefKind 1157bool filterIsReadOnlyAttribute = this.RefKind == RefKind.In; 1158bool filterRequiresLocationAttribute = this.RefKind == RefKind.RefReadOnlyParameter;

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

35private readonly RefKind _refKind; 233var isBad = (result.RefKind == RefKind.In) != result.RefCustomModifiers.HasInAttributeModifier(); 304_refKind = RefKind.RefReadOnly; 308_refKind = RefKind.Ref; 313_refKind = RefKind.None; 399if (this.RefKind != RefKind.None && _setMethod != null) 742public override RefKind RefKind 835var filterIsReadOnlyAttribute = this.RefKind == RefKind.RefReadOnly;

Symbols\MethodSymbol.cs (5)

227return this.RefKind == RefKind.Ref; 238Debug.Assert(this.RefKind != RefKind.Out); 239return this.RefKind == RefKind.RefReadOnly; 246public abstract RefKind RefKind { get; } 928internal ImmutableArray<RefKind> ParameterRefKinds

Symbols\NamedTypeSymbol.cs (8)

392if (thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) 397if (thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter 1966RefKind: RefKind.None, 1968Parameters: [{ RefKind: RefKind.In or RefKind.None }] 2002return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] };

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)); 475RefKind 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 544internal 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)

393if (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 (9)

23private RefKind _refKind; 50ImmutableArray<RefKind> parameterRefKinds, 51RefKind refKind, 150public override RefKind RefKind 169internal void SetInferredReturnType(RefKind refKind, TypeWithAnnotations inferredReturnType) 173Debug.Assert(refKind != RefKind.RefReadOnly); 183/// True if <see cref="SetInferredReturnType(RefKind, TypeWithAnnotations)"/> changed whether <see cref="CSharpCompilation.IsRuntimeAsyncEnabledIn(Symbol?)"/> returns true for this method. 341ImmutableArray<RefKind> parameterRefKinds) 364var refKind = unboundLambda.RefKind(p);

Symbols\Source\LocalFunctionSymbol.cs (5)

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

Symbols\Source\ParameterHelpers.cs (36)

Symbols\Source\SourceAssemblySymbol.cs (1)

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

Symbols\Source\SourceClonedParameterSymbol.cs (1)

97public override RefKind RefKind

Symbols\Source\SourceComplexParameterSymbol.cs (10)

46RefKind refKind, 905return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 930if (this.RefKind == RefKind.RefReadOnlyParameter && this.IsOptional && this.ParameterSyntax.Default is null) 1459case RefKind.Ref: 1466case RefKind.Out: 1473case RefKind.In: 1480case RefKind.RefReadOnlyParameter: 1762RefKind refKind, 1788RefKind refKind, 1804Debug.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); 222: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 225SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 226SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 264RefKind refKind, 287if (this.RefKind == RefKind.RefReadOnly) 326if (this.RefKind == RefKind.RefReadOnly) 362: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 372parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 373parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 411if (p.RefKind != RefKind.None) 418parameters.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)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (19)

1314overrideMethod.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.Out, 1380RefKind refKind, 1386case RefKind.Ref: 1392case RefKind.Out: 1427p is { EffectiveScope: ScopedKind.None, RefKind: RefKind.Ref } or { EffectiveScope: ScopedKind.ScopedRef, RefKind: RefKind.Out } && 1438if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1440(method.RefKind is RefKind.Ref or RefKind.RefReadOnly)) 1444else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1455int nRefParameters = parameters.Count(p => p.RefKind is RefKind.Ref or RefKind.In or RefKind.RefReadOnlyParameter or RefKind.Out); 1460else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))

Symbols\Source\SourceMemberFieldSymbol.cs (13)

372internal readonly RefKind RefKind; 375internal TypeAndRefKind(RefKind refKind, TypeWithAnnotations type) 467public sealed override RefKind RefKind => GetTypeAndRefKind(ConsList<FieldSymbol>.Empty).RefKind; 497RefKind refKind = RefKind.None; 535Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 537if (refKind != RefKind.None) 553type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRefInField(out RefKind refKindToAssert), diagnostics, out isVar); 554Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error 585var initializerOpt = executableBinder.BindInferredVariableInitializer(diagnostics, RefKind.None, syntaxNode, declarator); 614if (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, 1141public sealed override RefKind RefKind => this.flags.RefKind;

Symbols\Source\SourceMethodSymbol.cs (1)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)

785if (param.RefKind == RefKind.Out) 1417static void checkAndReportManagedTypes(TypeSymbol type, RefKind refKind, SyntaxNode syntax, bool isParam, BindingDiagnosticBag diagnostics) 1419if (refKind != RefKind.None) 1542if (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) 246if (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 890else 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 888if (RefKind != RefKind.None && IsRequired) 912if (this.RefKind != RefKind.None) 949if (_refKind != RefKind.None) 976else if (RefKind != RefKind.None) 1048if (_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)

108public 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); 125public 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\SynthesizedEmbeddedAttributePropertySymbol.cs (4)

26public override RefKind RefKind => RefKind.None; 89public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (1)

41return [SynthesizedParameterSymbol.Create(ctor, TypeWithAnnotations.Create(systemStringType), ordinal: 0, RefKind.None, name: "name")];

Symbols\Synthesized\SynthesizedEmbeddedMemorySafetyRulesAttributeSymbol.cs (1)

66refKind: 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; } 304default(ImmutableArray<RefKind>), 372argumentRefKindsOpt: default(ImmutableArray<RefKind>), 398argumentRefKindsOpt: default(ImmutableArray<RefKind>), 451refKind: RefKind.None, 469refKind: RefKind.None, 563RefKind.None, 582TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 633argumentRefKindsOpt: default(ImmutableArray<RefKind>), 654RefKind.None,

Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (2)

31public 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; 475) : base(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, ScopedKind.None, name) 479internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 481internal override bool IsMetadataOut => RefKind == RefKind.Out;

Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (2)

38public 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\SynthesizedUnionCtor.cs (1)

26Parameters = [SynthesizedParameterSymbol.Create(this, parameterType, ordinal: 0, RefKind.None, ParameterSymbol.ValueParameterName)];

Symbols\Synthesized\SynthesizedUnionValuePropertySymbol.cs (1)

35RefKind.None,

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

113public override RefKind RefKind

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

159public override RefKind RefKind => RefKind.None;

Symbols\Tuples\TupleFieldSymbol.cs (1)

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

Symbols\TypeSymbol.cs (3)

2029RefKind interfaceMemberRefKind = RefKind.None; 2589return 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;