RefKind

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

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

Binder\Binder.QueryUnboundLambdaState.cs (3)

38public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType) 49public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }

Binder\Binder.ValueChecks.cs (130)

Binder\Binder_AnonymousTypes.cs (1)

96RefKind.None,

Binder\Binder_Attributes.cs (4)

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

Binder\Binder_Conversions.cs (8)

1510parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds); 1893if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 2902{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 2946RefKind sourceRefKind, RefKind destinationRefKind, bool checkingReturns, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2951: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 2956if (sourceRefKind != RefKind.None)

Binder\Binder_Crefs.cs (7)

276refKind: RefKind.None, 304refKind: RefKind.None, 953refKind: RefKind.None, 970refKind: RefKind.None, 1094RefKind refKind = parameter.RefKindKeyword.Kind().GetRefKind(); 1095if (refKind == RefKind.Ref && parameter.ReadOnlyKeyword.IsKind(SyntaxKind.ReadOnlyKeyword)) 1098refKind = RefKind.RefReadOnlyParameter;

Binder\Binder_Deconstruct.cs (2)

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

Binder\Binder_Expressions.cs (65)

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)

294else if (analyzedArguments.RefKind(i) == RefKind.None) 301case RefKind.None: 302case RefKind.Ref: 313ImmutableArray<RefKind> refKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 548ImmutableArray<RefKind> refKinds, 567if (refKinds[argIndex] == RefKind.In) 1265if (receiverParameter.RefKind == RefKind.Ref) 1278analyzedArguments.RefKinds[0] = RefKind.Ref; 1281else if (receiverParameter.RefKind == RefKind.In) 1284Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1366CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1368if (extensionParameter.RefKind == RefKind.Ref) 1525ArrayBuilder<RefKind>? argumentRefKindsBuilder, 1610argumentRefKindsBuilder.Add(RefKind.None); 1635argumentRefKindsBuilder.Add(RefKind.None);

Binder\Binder_Lambda.cs (8)

47ImmutableArray<RefKind> refKinds = default; 51RefKind returnRefKind = RefKind.None; 128var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(); 181var refKind = ParameterHelpers.GetModifiers(p.Modifiers, ignoreParams: false, out _, out var paramsKeyword, out _, out var scope); 221if (refKindsBuilder.Any(r => r != RefKind.None)) 291private (RefKind, TypeWithAnnotations) BindExplicitLambdaReturnType(TypeSyntax syntax, BindingDiagnosticBag diagnostics) 296syntax = syntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind);

Binder\Binder_Operators.cs (15)

434analyzedArguments.RefKinds.Add(RefKind.Ref); 435analyzedArguments.RefKinds.Add(RefKind.None); 3363analyzedArguments.RefKinds.Add(RefKind.Ref); 3640(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3697!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3698(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4034if (parameterSymbol.RefKind != RefKind.None) 4065return localSymbol.RefKind != RefKind.None; 5662var whenTrue = node.WhenTrue.CheckAndUnwrapRefExpression(diagnostics, out var whenTrueRefKind); 5663var whenFalse = node.WhenFalse.CheckAndUnwrapRefExpression(diagnostics, out var whenFalseRefKind); 5665var isRef = whenTrueRefKind == RefKind.Ref && whenFalseRefKind == RefKind.Ref; 5668if (whenFalseRefKind == RefKind.Ref) 5673if (whenTrueRefKind == RefKind.Ref)

Binder\Binder_Query.cs (3)

696return lambdaBodyBinder.CreateBlockFromExpression(node, ImmutableArray<LocalSymbol>.Empty, RefKind.None, construction, null, d); 776return this.CreateBlockFromExpression(expression, locals, RefKind.None, result, expression, diagnostics); 818new 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.GetIsNewExtensionMember() && getEnumeratorMethod.ContainingType.ExtensionParameter.RefKind == RefKind.Ref) 333if (local.RefKind != RefKind.None) 346case RefKind.None: 349case RefKind.Ref: 352case RefKind.RefReadOnly: 485if (elementConversionClassification.Kind != ConversionKind.Identity && IterationVariable.RefKind is RefKind.Ref or RefKind.RefReadOnly) 881builder.CurrentPropertyGetter?.RefKind == (wellKnownSpan == WellKnownType.System_ReadOnlySpan_T ? RefKind.RefReadOnly : RefKind.Ref)) || 1232patternDisposeMethod.ParameterRefKinds.All(static refKind => refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));

Binder\InMethodBinder.cs (5)

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

Binder\LockBinder.cs (1)

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

Binder\RefSafetyAnalysis.cs (5)

492Debug.Assert(localSymbol.RefKind == RefKind.None || 506if (localSymbol.RefKind != RefKind.None) 523ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1114ImmutableArray<RefKind> refKinds; 1142AddLocalScopes(local, refEscapeScope: local.RefKind == RefKind.None ? _localScopeDepth : collectionEscape, valEscapeScope: collectionEscape);

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

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

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

1325if (op1.LeftRefKind == RefKind.None && op2.LeftRefKind == RefKind.In) 1329else if (op2.LeftRefKind == RefKind.None && op1.LeftRefKind == RefKind.In) 1338if (op1.RightRefKind == RefKind.None && op2.RightRefKind == RefKind.In) 1349else 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)

477if (op1.RefKind == RefKind.None && op2.RefKind == RefKind.In) 481else 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)

137private readonly ImmutableArray<RefKind> _formalParameterRefKinds; 275ImmutableArray<RefKind> formalParameterRefKinds, // Optional; assume all value if missing. 328ImmutableArray<RefKind> formalParameterRefKinds, 439private RefKind GetRefKind(int index) 442return _formalParameterRefKinds.IsDefault ? RefKind.None : _formalParameterRefKinds[index]; 1505RefKind delegateRefKind, 2449if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2459if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None) 2799if ((sourceParam.Type.IsReferenceType || sourceParam.Type.IsFunctionPointer()) && sourceParam.RefKind == RefKind.None) 2809if ((sourceSignature.ReturnType.IsReferenceType || sourceSignature.ReturnType.IsFunctionPointer()) && sourceSignature.RefKind == RefKind.None)

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

145RefKind returnRefKind = default, 193RefKind returnRefKind = default, 434RefKind returnRefKind, 850RefKind? returnRefKind, 875else if (returnRefKind == RefKind.None) 2199var type1 = getParameterTypeAndRefKind(i, m1.Result, m1LeastOverriddenParameters, m1.Result.ParamsElementTypeOpt, m1.LeastOverriddenMember, out RefKind parameter1RefKind); 2201var type2 = getParameterTypeAndRefKind(i, m2.Result, m2LeastOverriddenParameters, m2.Result.ParamsElementTypeOpt, m2.LeastOverriddenMember, out RefKind parameter2RefKind); 2591TypeWithAnnotations paramsElementTypeOpt, TMember member, out RefKind parameter1RefKind) 2663if (p1.RefKind == RefKind.None && isAcceptableRefMismatch(p2.RefKind, isInterpolatedStringHandlerConversion)) 2674else if (p2.RefKind == RefKind.None && isAcceptableRefMismatch(p1.RefKind, isInterpolatedStringHandlerConversion)) 2690static bool isAcceptableRefMismatch(RefKind refKind, bool isInterpolatedStringHandlerConversion) 2693RefKind.In or RefKind.RefReadOnlyParameter => true, 2694RefKind.Ref when isInterpolatedStringHandlerConversion => true, 2871RefKind refKind1, 2874RefKind refKind2, 2899Debug.Assert(refKind1 == RefKind.None || refKind1 == RefKind.Ref); 2900Debug.Assert(refKind2 == RefKind.None || refKind2 == RefKind.Ref); 2904if (refKind1 == RefKind.None) 2913else if (refKind1 == RefKind.Ref) 3837ArrayBuilder<RefKind> argumentRefKinds, 3843out ImmutableArray<RefKind> parameterRefKinds) 3859internal readonly ImmutableArray<RefKind> ParameterRefKinds; 3862internal EffectiveParameters(ImmutableArray<TypeWithAnnotations> types, ImmutableArray<RefKind> refKinds, int firstParamsElementIndex) 3876ArrayBuilder<RefKind> argumentRefKinds, 3897hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None; 3908ArrayBuilder<RefKind> refs = null; 3922RefKind argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 3923RefKind paramRefKind = GetEffectiveParameterRefKind(parameter, argRefKind, options, binder, ref hasAnyRefOmittedArgument); 3927if (paramRefKind != RefKind.None) 3929refs = ArrayBuilder<RefKind>.GetInstance(arg, RefKind.None); 3939var refKinds = refs != null ? refs.ToImmutableAndFree() : default(ImmutableArray<RefKind>); 3943private static RefKind GetEffectiveParameterRefKind( 3945RefKind argRefKind, 3950var paramRefKind = parameter.RefKind; 3959if (paramRefKind == RefKind.In) 3961if (argRefKind == RefKind.None) 3963return RefKind.None; 3966if (argRefKind == RefKind.Ref && binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters)) 3968return RefKind.Ref; 3971else if (paramRefKind == RefKind.RefReadOnlyParameter && argRefKind is RefKind.None or RefKind.Ref or RefKind.In) 3984if ((options & Options.AllowRefOmittedArguments) != 0 && paramRefKind == RefKind.Ref && argRefKind == RefKind.None && !binder.InAttributeArgument) 3987return RefKind.None; 3996internal static bool AreRefsCompatibleForMethodConversion(RefKind candidateMethodParameterRefKind, RefKind delegateParameterRefKind, CSharpCompilation compilation) 4006(RefKind.RefReadOnlyParameter, RefKind.Ref) or 4007(RefKind.RefReadOnlyParameter, RefKind.In) or 4008(RefKind.In, RefKind.RefReadOnlyParameter)) 4014(candidateMethodParameterRefKind, delegateParameterRefKind) is (RefKind.In, RefKind.Ref)) 4026ArrayBuilder<RefKind> argumentRefKinds, 4037ArrayBuilder<RefKind> argumentRefKinds, 4045var refs = ArrayBuilder<RefKind>.GetInstance(); 4075var argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 4076var paramRefKind = GetEffectiveParameterRefKind(parameter, argRefKind, options, binder, ref hasAnyRefOmittedArgument); 4079if (paramRefKind != RefKind.None) 4085var refKinds = anyRef ? refs.ToImmutable() : default(ImmutableArray<RefKind>); 4557RefKind argumentRefKind = arguments.RefKind(argumentPosition); 4558RefKind parameterRefKind = parameters.ParameterRefKinds.IsDefault ? RefKind.None : parameters.ParameterRefKinds[argumentPosition]; 4563if (argumentRefKind == RefKind.None) 4565if (parameterRefKind == RefKind.Ref) 4584&& parameterRefKind == RefKind.Ref 4680RefKind argRefKind, 4682RefKind parRefKind, 4719Debug.Assert(argRefKind != RefKind.None); 4725if (argRefKind == RefKind.None || hasInterpolatedStringRefMismatch)

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

202RefKind? returnRefKind = null, 1122if (parameters[i].RefKind != RefKind.None) 1191RefKind refArg = arguments.RefKind(arg); 1192RefKind refParameter = parameter.RefKind; 1196Debug.Assert(refArg == RefKind.None); 1197if (refParameter == RefKind.Ref || refParameter == RefKind.In) 1255!(refArg == RefKind.None && refParameter == RefKind.In) && 1256!(refArg == RefKind.Ref && refParameter == RefKind.In && binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters)) && 1257!(refParameter == RefKind.RefReadOnlyParameter && refArg is RefKind.None or RefKind.Ref or RefKind.In)) 1262refParameter != RefKind.Out) 1267else if (refArg == RefKind.Ref && refParameter == RefKind.In && !binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters)) 1278else if (refParameter is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)

Binder\WithLambdaParametersBinder.cs (1)

47protected override TypeSymbol GetCurrentReturnType(out RefKind refKind)

BoundTree\BoundExpression.cs (1)

546ImmutableArray<RefKind> newRefKinds,

BoundTree\BoundExpressionExtensions.cs (7)

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;

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

BoundTree\UnboundLambda.cs (49)

CodeGen\CodeGenerator.cs (1)

169var 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\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 (53)

CodeGen\EmitStatement.cs (10)

749Debug.Assert(local.RefKind == RefKind.None || local.SynthesizedKind.IsLongLived(), 865if (boundReturnStatement.RefKind == RefKind.None) 873var unexpectedTemp = this.EmitAddress(expressionOpt, this._method.RefKind == RefKind.RefReadOnly ? AddressKind.ReadOnlyStrict : AddressKind.Writeable); 1147Debug.Assert(exceptionSourceLocal.LocalSymbol.RefKind == RefKind.None); 1159Debug.Assert(left.FieldSymbol.RefKind == RefKind.None); 1283if (local.RefKind == RefKind.None && !IsStackLocal(local)) 1292if (parameter.ParameterSymbol.RefKind == RefKind.None) 1766CSharpCompilation.DynamicTransformsEncoder.Encode(local.Type, RefKind.None, 0) : 1796Debug.Assert(local.RefKind == RefKind.None); 1812(local.RefKind != RefKind.None ? LocalSlotConstraints.ByRef : LocalSlotConstraints.None);

CodeGen\Optimizer.cs (23)

857if (node.LocalSymbol.RefKind != RefKind.None) 877if (node.LocalSymbol.RefKind != RefKind.None) 985if (localSymbol.RefKind is RefKind.RefReadOnly or RefKindExtensions.StrictIn && 1030(lhs.Kind is BoundKind.Local or BoundKind.Parameter or BoundKind.FieldAccess && lhs.GetRefKind() != RefKind.None), 1040if (((BoundParameter)lhs).ParameterSymbol.RefKind != RefKind.None) 1048if (((BoundLocal)lhs).LocalSymbol.RefKind != RefKind.None) 1056Debug.Assert(((BoundCall)lhs).Method.RefKind == RefKind.Ref, "only ref returning methods are assignable"); 1060Debug.Assert(((BoundFunctionPointerInvocation)lhs).FunctionPointer.Signature.RefKind == RefKind.Ref, "only ref returning function pointers are assignable"); 1220if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1254private ImmutableArray<BoundExpression> VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt) 1264RefKind argRefKind = CodeGenerator.GetArgumentRefKind(arguments, parameters, argRefKindsOpt, i); 1271private void VisitArgument(ImmutableArray<BoundExpression> arguments, ref ArrayBuilder<BoundExpression> rewrittenArguments, int i, RefKind argRefKind) 1273ExprContext context = (argRefKind == RefKind.None) ? ExprContext.Value : ExprContext.Address; 1295ImmutableArray<RefKind> argRefKindsOpt = node.ArgumentRefKindsOpt; 1299RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1427if (localSym.RefKind == RefKind.None) 1873Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1934return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2161var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2190left.LocalSymbol.RefKind == RefKind.Ref && 2427public override RefKind RefKind 2429get { return RefKind.None; }

Compilation\CSharpCompilation.cs (5)

2250if (method.RefKind != RefKind.None) 4089RefKind returnRefKind, 4091ImmutableArray<RefKind> parameterRefKinds, 4124if (returnRefKind == RefKind.Out) 4264fields.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, 193statement = new BoundReturnStatement(accessor.SyntaxNode, RefKind.None, fieldAccess, @checked: false); 311BoundStatement returnStatement = BoundReturnStatement.Synthesized(syntax, RefKind.None, processHandlerCall); 321BoundStatement returnStatement = new BoundReturnStatement(syntax, RefKind.None, expressionOpt: null, @checked: false); 358refKind: RefKind.None,

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (8)

664return parameter.RefKind is RefKind.None == other.RefKind is RefKind.None && 701private static void ValidateFunctionPointerParamOrReturn(TypeWithAnnotations type, RefKind refKind, ImmutableArray<CustomModifier> refCustomModifiers, bool allowOut) 706static bool verifyRefModifiers(ImmutableArray<CustomModifier> modifiers, RefKind refKind, bool allowOut) 708Debug.Assert(RefKind.RefReadOnly == RefKind.In); 711case RefKind.RefReadOnly: 712case 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)

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

Emitter\Model\SpecializedFieldReference.cs (1)

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

FlowAnalysis\AbstractFlowPass.cs (37)

1131VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), null, default, false); 1292VisitRvalue(node.InitializerOpt, isKnownToBeAnLvalue: node.LocalSymbol.RefKind != RefKind.None); 1295if (node.LocalSymbol.RefKind != RefKind.None) 1435WriteArgument(receiverOpt, RefKind.Ref, method: null); 1441var thisRefKind = thisParameter.RefKind; 1515protected virtual void VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1522private void VisitArgumentsBeforeCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt) 1527RefKind refKind = GetRefKind(refKindsOpt, i); 1528if (refKind != RefKind.Out) 1530VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1543private void VisitArgumentsAfterCall(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol? method, ImmutableArray<int> argsToParamsOpt, bool expanded) 1547RefKind refKind = GetRefKind(refKindsOpt, i); 1550case RefKind.None: 1551case RefKind.In: 1552case RefKind.RefReadOnlyParameter: 1555case RefKind.Ref: 1558goto case RefKind.Out; 1561case RefKind.Out: 1572protected static RefKind GetRefKind(ImmutableArray<RefKind> refKindsOpt, int index) 1574return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index]; 1577protected virtual void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2032VisitRvalue(node.ExpressionOpt, isKnownToBeAnLvalue: node.RefKind != RefKind.None); 2035if (node.RefKind != RefKind.None) 2145if (property.RefKind == RefKind.None) 2163var refKind = node.Left.Kind == BoundKind.BadExpression 2164? RefKind.Ref 2200if (property.RefKind == RefKind.None) 2219if (property.RefKind == RefKind.None) 2836if (property.RefKind == RefKind.None) 3338WriteArgument(operand, RefKind.Ref, method: null); 3524this.WriteArgument(operand, RefKind.Out, null); //Out because we know it will definitely be assigned. 3565VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.Constructor, default, false); 3649VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3655VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), node.AddMethod, node.ArgsToParamsOpt, node.Expanded); 3663VisitArguments(node.Arguments, default(ImmutableArray<RefKind>), method: null, default, false); 3745property.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); 860write: field.RefKind == RefKind.None || isRef); 972write: field.RefKind == RefKind.None || isRef); 1235((ParameterSymbol)symbol).RefKind == RefKind.Out) 1335if (fieldSymbol.RefKind != RefKind.None) 1519if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess) 1572if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 1623if (isRef && param.RefKind == RefKind.Out) 1641write: field.RefKind == RefKind.None || isRef); 1815if (parameter.RefKind != RefKind.Out) 1827if (thisParameter.RefKind != RefKind.Out) 1839if (extensionParameter.RefKind != RefKind.Out) 1862if (current is not MethodSymbol && parameter.RefKind == RefKind.Out) 1892if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async 1900NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1958if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor) 1970if (parameter.RefKind != RefKind.None) 2580protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2582if (refKind == RefKind.Ref) 2596if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2784NoteWrite(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)); 138if (field.RefKind == RefKind.None) 202: BoundReturnStatement.Synthesized(syntax, RefKind.None, null);

FlowAnalysis\NullableWalker.cs (66)

FlowAnalysis\NullableWalker.PlaceholderLocal.cs (2)

59public override RefKind RefKind => RefKind.None;

FlowAnalysis\ReadWriteWalker.cs (3)

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

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

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

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

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

488method.RefKind == RefKind.None &&

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (1)

443refKinds: ImmutableArray<RefKind>.Empty,

Lowering\ClosureConversion\ClosureConversion.cs (7)

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

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

139public override RefKind RefKind => RefKind.None;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

117if (RefKind == RefKind.RefReadOnly)

Lowering\DiagnosticsPass_ExpressionTrees.cs (5)

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

Lowering\DiagnosticsPass_Warnings.cs (5)

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

Lowering\ExtensionMethodReferenceRewriter.cs (7)

96ImmutableArray<RefKind> argumentRefKinds, 105var receiverRefKind = method.Parameters[0].RefKind; 109if (receiverRefKind != RefKind.None) 111var builder = ArrayBuilder<RefKind>.GetInstance(method.ParameterCount, RefKind.None); 145static RefKind argumentRefKindFromReceiverRefKind(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 (5)

307if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 448Debug.Assert(parameter.RefKind == RefKind.None); 552private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds) 577if (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)

1087return ((BoundCall)expr).Method.RefKind != RefKind.None; 1090return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1093return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None; 1128symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

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

Lowering\LocalRewriter\LocalRewriter_AnonymousObjectCreation.cs (1)

28argumentRefKindsOpt: default(ImmutableArray<RefKind>),

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (4)

144ImmutableArray<RefKind> refKinds, 191default(ImmutableArray<RefKind>), 222Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None); 272ImmutableArray<RefKind> argumentRefKindsOpt,

Lowering\LocalRewriter\LocalRewriter_Call.cs (81)

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (20)

277var receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind: variableRepresentsLocation ? RefKind.Ref : RefKind.None); 396ImmutableArray<RefKind> argumentRefKinds = indexerAccess.ArgumentRefKindsOpt; 404ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 497Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None); 520var variableTemp = _factory.StoreToTemp(arrayAccess, out assignmentToTemp, refKind: RefKind.Ref); 598var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 669if (propertyAccess.PropertySymbol.RefKind == RefKind.None) 684if (indexerAccess.GetRefKind() == RefKind.None) 697if (implicitIndexerAccess.GetRefKind() == RefKind.None) 750Debug.Assert(originalLHS.GetRefKind() == RefKind.Ref); 771Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 775Debug.Assert(((BoundFunctionPointerInvocation)originalLHS).FunctionPointer.Signature.RefKind != RefKind.None); 826var variableTemp = _factory.StoreToTemp(rewrittenVariable, out assignmentToTemp2, refKind: RefKind.Ref); 926((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None || 930return 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)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (11)

54ImmutableArray<RefKind> refKinds) 107ImmutableArray<RefKind> argumentRefKindsOpt, 116if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 273possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref); 448Debug.Assert(!isLeftOfAssignment || node.IndexerOrSliceAccess.GetRefKind() == RefKind.Ref); 505receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 570if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 807receiver.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_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; 352default(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)

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

Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (2)

636return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 640return ((BoundParameter)expression).ParameterSymbol.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)

267if (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: RefKind.Ref } receiverRefLocal }, 541ValueTypeReceiver: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.Ref } } valueTypeReceiver, 550Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 551Right: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.Ref } originalReceiverReference } 554Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 586ImmutableArray<RefKind> refKinds = default(ImmutableArray<RefKind>), 634var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 892expression = Spill(leftBuilder, expression, RefKind.None); 907left = Spill(leftBuilder, VisitExpression(ref leftBuilder, left), RefKind.Ref); 939expression = Spill(leftBuilder, expression, RefKind.None); 954receiver = Spill(leftBuilder, VisitExpression(ref leftBuilder, field.ReceiverOpt), RefKind.Ref); 1032RefKind refKind = ReceiverSpillRefKind(receiver); 1034Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1038if (refKind != RefKind.None && 1071private static RefKind ReceiverSpillRefKind(BoundExpression receiver) 1073var result = RefKind.None; 1076result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1265var receiverRefKind = ReceiverSpillRefKind(node.Receiver); 1286if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1289receiver = Spill(receiverBuilder, receiver, RefKind.None); 1304receiver = Spill(receiverBuilder, receiver, RefKind.Ref); 1306var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (3)

91Debug.Assert(local.RefKind != RefKind.None); 213(variable is LocalSymbol { RefKind: not RefKind.None } refLocal && !canRefLocalBeHoisted(refLocal))) 251Debug.Assert(parameter.IsThis || parameter.RefKind == RefKind.None);

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (20)

313if (local.RefKind != RefKind.None) 565var sacrificialTemp = F.SynthesizedLocal(type, refKind: RefKind.Ref); 585RefKind refKind, 595BoundExpression expression = HoistExpression(array.Expression, awaitSyntaxOpt, syntaxOffset, RefKind.None, sideEffects, hoistedFields, ref needsSacrificialEvaluation); 599indices.Add(HoistExpression(index, awaitSyntaxOpt, syntaxOffset, RefKind.None, sideEffects, hoistedFields, ref needsSacrificialEvaluation)); 612if (refKind != RefKind.None || field.FieldSymbol.IsReadOnly) return expr; 616if (refKind == RefKind.None) 624isFieldOfStruct ? refKind : RefKind.None, sideEffects, hoistedFields, ref needsSacrificialEvaluation); 646if (refKind != RefKind.None && refKind != RefKind.In) 648Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.Out); 649Debug.Assert(call.Method.RefKind != RefKind.None); 653refKind = RefKind.None; 664if (refKind != RefKind.None && refKind != RefKind.RefReadOnly) 666Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.In); 671refKind = RefKind.None; 680if (refKind != RefKind.None)

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (2)

64public override RefKind RefKind => RefKind.None;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)

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

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

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

Lowering\SynthesizedMethodBaseSymbol.cs (1)

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

Lowering\SyntheticBoundNodeFactory.cs (27)

574Debug.Assert(CurrentFunction.RefKind == RefKind.None); 599RefKind refKind = RefKind.None, 639return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 762public BoundObjectCreationExpression New(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKinds) 872public static ImmutableArray<RefKind> ArgumentRefKindsFromParameterRefKinds(MethodSymbol method, bool useStrictArgumentRefKinds) 876if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 877(useStrictArgumentRefKinds && result.Contains(RefKind.In)))) 879var builder = ArrayBuilder<RefKind>.GetInstance(result.Length); 881foreach (var refKind in result) 892public static RefKind ArgumentRefKindFromParameterRefKind(RefKind refKind, bool useStrictArgumentRefKinds) 896RefKind.In or RefKind.RefReadOnlyParameter when useStrictArgumentRefKinds => RefKindExtensions.StrictIn, 897RefKind.RefReadOnlyParameter => RefKind.In, 902public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1651RefKind refKind = RefKind.None, 1668case RefKind.Out: 1669refKind = RefKind.Ref; 1672case RefKind.In: 1681Debug.Assert(argument.GetRefKind() != RefKind.In); 1682refKind = RefKind.None; 1686case RefKind.None: 1687case RefKind.Ref: 1718isRef: refKind != RefKind.None);

Operations\CSharpOperationFactory.cs (6)

752ImmutableArray<RefKind> argumentRefKinds = boundDynamicObjectCreationExpression.ArgumentRefKindsOpt.NullToEmpty(); 781ImmutableArray<RefKind> argumentRefKinds = boundDynamicInvocation.ArgumentRefKindsOpt.NullToEmpty(); 824ImmutableArray<RefKind> argumentRefKinds = boundDynamicIndexerAccess.ArgumentRefKindsOpt.NullToEmpty(); 863ImmutableArray<RefKind> argumentRefKinds = boundObjectInitializerMember.ArgumentRefKindsOpt.NullToEmpty(); 884MethodSymbol? accessor = isObjectOrCollectionInitializer || property.RefKind != RefKind.None 981return 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 (2)

259if (fields.Any(static f => f.RefKind != RefKind.None)) 463var fields = key.Fields.SelectAsArray(f => new AnonymousTypeField(f.Name, Location.None, typeWithAnnotations: default, refKind: RefKind.None, ScopedKind.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)

777internal SynthesizedAttributeData? SynthesizeDynamicAttribute(TypeSymbol type, int customModifiersCount, RefKind refKindOpt = RefKind.None) 782if (type.IsDynamic() && refKindOpt == RefKind.None && customModifiersCount == 0) 891internal static ImmutableArray<TypedConstant> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount, TypeSymbol booleanType) 903internal static ImmutableArray<bool> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount) 910internal static ImmutableArray<bool> EncodeWithoutCustomModifierFlags(TypeSymbol type, RefKind refKind) 917internal static void Encode(TypeSymbol type, int customModifiersCount, RefKind refKind, ArrayBuilder<bool> transformFlagsBuilder, bool addCustomModifierFlags) 921if (refKind != RefKind.None) 1012void handle(RefKind refKind, ImmutableArray<CustomModifier> customModifiers, TypeWithAnnotations twa) 1019if (refKind != RefKind.None) 1174return parameter.RefKind != RefKind.None; 1179return method.RefKind != RefKind.None; 1184return 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)

24MethodKind.Ordinary, RefKind.None, GetDeclarationModifiers(), returnsVoid: false, returnsVoidIsSet: false, 82RefKind parameterRefKind = parameter.RefKind; 91else if (parameterRefKind == RefKind.Ref && !parameterType.IsValueType) 95else if (parameterRefKind is RefKind.In or RefKind.RefReadOnlyParameter && parameterType.TypeKind != TypeKind.Struct) 100if (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; } 79internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 80internal override bool IsMetadataOut => RefKind == RefKind.Out;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (13)

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

Symbols\LocalSymbol.cs (2)

365public bool IsRef => RefKind != RefKind.None; 367public abstract RefKind RefKind

Symbols\MemberSignatureComparer.cs (14)

254/// the difference between <see cref="RefKind.Out"/> and <see cref="RefKind.Ref"/>. 566RefKind refKind1; 571RefKind refKind2; 811var refKind1 = param1.RefKind; 812var refKind2 = param2.RefKind; 824if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None)) 832static bool areRefKindsCompatible(RefKindCompareMode refKindCompareMode, RefKind refKind1, RefKind refKind2) 841return (refKind1, refKind2) is (RefKind.RefReadOnlyParameter, RefKind.In) or (RefKind.In, RefKind.RefReadOnlyParameter);

Symbols\MemberSymbolExtensions.cs (2)

317internal static ImmutableArray<RefKind> GetParameterRefKinds(this Symbol member) 326return default(ImmutableArray<RefKind>);

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

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

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

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

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

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

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

662public override RefKind RefKind => Signature.ReturnParam.RefKind; 1128case RefKind.None: 1129case RefKind.Ref: 1130case RefKind.In: 1131case RefKind.RefReadOnlyParameter: 1155foreach (var kind in this.ParameterRefKinds) 1159case RefKind.None: 1160case RefKind.In: 1162case RefKind.Out: 1163case RefKind.Ref: 1164case RefKind.RefReadOnlyParameter:

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

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

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

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

Symbols\MethodSymbol.cs (5)

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

Symbols\NamedTypeSymbol.cs (3)

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

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)); 457RefKind 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)

327RefKind 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)

489public override RefKind RefKind 541internal 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 (7)

23private RefKind _refKind; 48ImmutableArray<RefKind> parameterRefKinds, 49RefKind refKind, 146public override RefKind RefKind 160internal void SetInferredReturnType(RefKind refKind, TypeWithAnnotations inferredReturnType) 326ImmutableArray<RefKind> parameterRefKinds) 349var refKind = unboundLambda.RefKind(p);

Symbols\Source\LocalFunctionSymbol.cs (4)

23private readonly RefKind _refKind; 243public override RefKind RefKind => _refKind; 267if (_refKind == RefKind.RefReadOnly) 292Debug.Assert(_refKind == RefKind.None

Symbols\Source\ParameterHelpers.cs (37)

Symbols\Source\SourceAssemblySymbol.cs (1)

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

Symbols\Source\SourceClonedParameterSymbol.cs (1)

93public override RefKind RefKind

Symbols\Source\SourceComplexParameterSymbol.cs (10)

44RefKind refKind, 878return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 903if (this.RefKind == RefKind.RefReadOnlyParameter && this.IsOptional && this.ParameterSyntax.Default is null) 1399case RefKind.Ref: 1406case RefKind.Out: 1413case RefKind.In: 1420case RefKind.RefReadOnlyParameter: 1691RefKind refKind, 1717RefKind refKind, 1733Debug.Assert(refKind != RefKind.None || _refCustomModifiers.IsEmpty);

Symbols\Source\SourceConstructorSymbol.cs (1)

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

Symbols\Source\SourceDelegateMethodSymbol.cs (13)

28RefKind refKind, 56returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind); 218: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 221SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 222SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 258RefKind refKind, 281if (this.RefKind == RefKind.RefReadOnly) 320if (this.RefKind == RefKind.RefReadOnly) 356: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 366parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 367parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 403if (p.RefKind != RefKind.None) 410parameters.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)

35private readonly RefKind _refKind; 69_scope = _refKind != RefKind.None 480public override RefKind RefKind

Symbols\Source\SourceMemberContainerSymbol.cs (18)

2197var refKind1 = method1.Parameters[i].RefKind; 2198var refKind2 = method2.Parameters[i].RefKind; 4494if (methodParam.RefKind != RefKind.None) 4517methodParams[0].RefKind == RefKind.None && 4910RefKind.Out 4912RefKind.None, 4958RefKind.None 4960RefKind.None, 5011RefKind.None)), 5012RefKind.None, 5067RefKind.None, 5146RefKind.None, 5241RefKind.None, 5272RefKind.None, 5338RefKind.None 5340RefKind.None, 5539_ = fieldSyntax.Declaration.Type.SkipScoped(out _).SkipRefInField(out var refKind); 5548var modifiers = SourceMemberFieldSymbol.MakeModifiers(this, fieldSyntax.Declaration.Variables[0].Identifier, fieldSyntax.Modifiers, isRefField: refKind != RefKind.None, diagnostics, out modifierErrors);

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (19)

1283overrideMethod.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.Out, 1349RefKind refKind, 1355case RefKind.Ref: 1361case RefKind.Out: 1396p is { EffectiveScope: ScopedKind.None, RefKind: RefKind.Ref } or { EffectiveScope: ScopedKind.ScopedRef, RefKind: RefKind.Out } && 1407if ((overrideThisParameter is { RefKind: RefKind.Ref or RefKind.Out } && overrideThisParameter.Type.IsRefLikeOrAllowsRefLikeType()) || 1409(method.RefKind is RefKind.Ref or RefKind.RefReadOnly)) 1413else if (parameters.Any(p => (p.RefKind is RefKind.Ref or RefKind.Out) && p.Type.IsRefLikeOrAllowsRefLikeType())) 1424int nRefParameters = parameters.Count(p => p.RefKind is RefKind.Ref or RefKind.In or RefKind.RefReadOnlyParameter or RefKind.Out); 1429else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))

Symbols\Source\SourceMemberFieldSymbol.cs (13)

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

Symbols\Source\SourceMemberMethodSymbol.cs (7)

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

Symbols\Source\SourceMethodSymbol.cs (1)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)

768if (param.RefKind == RefKind.Out) 1401static void checkAndReportManagedTypes(TypeSymbol type, RefKind refKind, SyntaxNode syntax, bool isParam, BindingDiagnosticBag diagnostics) 1403if (refKind != RefKind.None) 1526if (this.RefKind != RefKind.None)

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

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

Symbols\Source\SourceOrdinaryMethodSymbol.cs (6)

154Debug.Assert(this.RefKind == RefKind.None || !returnType.IsVoidType() || returnTypeSyntax.HasErrors); 211var parameter0RefKind = this.Parameters[0].RefKind; 220else if (parameter0RefKind == RefKind.Ref && !parameter0Type.Type.IsValueType) 224else if (parameter0RefKind is RefKind.In or RefKind.RefReadOnlyParameter && parameter0Type.TypeKind != TypeKind.Struct) 845else 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)

123case RefKind.In: 126case RefKind.RefReadOnlyParameter:

Symbols\Source\SourcePropertySymbolBase.cs (10)

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

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

24RefKind refKind, 36RefKind refKind,

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (8)

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

Symbols\Source\ThisParameterSymbol.cs (5)

148public override RefKind RefKind 154return RefKind.None; 159return RefKind.Out; 164return RefKind.In; 167return RefKind.Ref;

Symbols\SubstitutedFieldSymbol.cs (1)

106public override RefKind RefKind => _underlyingField.RefKind;

Symbols\SymbolExtensions.cs (4)

474internal static void GetTypeOrReturnType(this Symbol symbol, out RefKind refKind, out TypeWithAnnotations returnType, 481refKind = RefKind.None; 499refKind = RefKind.None; 516refKind = 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)

42RefKind.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)

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

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

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

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

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

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

40RefKind.None,

Symbols\Synthesized\RefKindVector.cs (11)

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

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (4)

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

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (6)

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) 163public override RefKind RefKind { get; }

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

115public override RefKind RefKind 117get { return RefKind.None; } 302default(ImmutableArray<RefKind>), 365argumentRefKindsOpt: default(ImmutableArray<RefKind>), 413refKind: RefKind.None, 431refKind: RefKind.None, 524RefKind.None, 543TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 594argumentRefKindsOpt: default(ImmutableArray<RefKind>), 615RefKind.None,

Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (2)

29public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedFieldSymbol.cs (2)

36public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (2)

19SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(stringType), ordinal: 0, RefKind.None), 20SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), ordinal: 1, RefKind.None)

Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)

96public sealed override RefKind RefKind

Symbols\Synthesized\SynthesizedInlineArrayAsReadOnlySpanMethod.cs (2)

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

Symbols\Synthesized\SynthesizedInlineArrayAsSpanMethod.cs (2)

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

Symbols\Synthesized\SynthesizedInlineArrayElementRefMethod.cs (4)

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

Symbols\Synthesized\SynthesizedInlineArrayElementRefReadOnlyMethod.cs (4)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefMethod.cs (3)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefReadOnlyMethod.cs (3)

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

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

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (2)

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

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (6)

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

Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (2)

36public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedLocal.cs (5)

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

Symbols\Synthesized\SynthesizedParameterSymbol.cs (14)

22private readonly RefKind _refKind; 29RefKind refKind, 47public override RefKind RefKind => _refKind; 186case RefKind.In: 189case RefKind.RefReadOnlyParameter: 244RefKind refKind, 251internal sealed override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter; 253internal sealed override bool IsMetadataOut => RefKind == RefKind.Out; 259RefKind refKind, 350RefKind refKind, 408internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter || _baseParameterForAttributes?.GetDecodedWellKnownAttributeData()?.HasInAttribute == true; 410internal override bool IsMetadataOut => RefKind == RefKind.Out || _baseParameterForAttributes?.GetDecodedWellKnownAttributeData()?.HasOutAttribute == true;

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

181public override RefKind RefKind

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedStaticConstructor.cs (2)

127public override RefKind RefKind 131return RefKind.None;

Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)

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

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

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

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

113public override RefKind RefKind

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

157public override RefKind RefKind => RefKind.None;

Symbols\Tuples\TupleFieldSymbol.cs (1)

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

Symbols\TypeSymbol.cs (3)

2020RefKind interfaceMemberRefKind = RefKind.None; 2577return 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)

56public override RefKind RefKind

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

44public sealed override RefKind RefKind

Symbols\Wrapped\WrappedPropertySymbol.cs (1)

47public 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;