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

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)

1524parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds); 1875if (method.Parameters is not [{ RefKind: RefKind.None, Type: var parameterType }] 2884{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 2928RefKind sourceRefKind, RefKind destinationRefKind, bool checkingReturns, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 2933: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 2938if (sourceRefKind != RefKind.None)

Binder\Binder_Crefs.cs (7)

282refKind: RefKind.None, 313refKind: RefKind.None, 992refKind: RefKind.None, 1009refKind: RefKind.None, 1133RefKind refKind = parameter.RefKindKeyword.Kind().GetRefKind(); 1134if (refKind == RefKind.Ref && parameter.ReadOnlyKeyword.IsKind(SyntaxKind.ReadOnlyKeyword)) 1137refKind = 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)

300else if (analyzedArguments.RefKind(i) == RefKind.None) 307case RefKind.None: 308case RefKind.Ref: 319ImmutableArray<RefKind> refKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 554ImmutableArray<RefKind> refKinds, 573if (refKinds[argIndex] == RefKind.In) 1286if (receiverParameter.RefKind == RefKind.Ref) 1299analyzedArguments.RefKinds[0] = RefKind.Ref; 1302else if (receiverParameter.RefKind == RefKind.In) 1305Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1387CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1389if (extensionParameter.RefKind == RefKind.Ref) 1546ArrayBuilder<RefKind>? argumentRefKindsBuilder, 1631argumentRefKindsBuilder.Add(RefKind.None); 1656argumentRefKindsBuilder.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)

440analyzedArguments.RefKinds.Add(RefKind.Ref); 441analyzedArguments.RefKinds.Add(RefKind.None); 3400analyzedArguments.RefKinds.Add(RefKind.Ref); 3677(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3734!((extensionParameter.Type.IsValueType && extensionParameter.RefKind == RefKind.Ref) || 3735(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4071if (parameterSymbol.RefKind != RefKind.None) 4102return localSymbol.RefKind != RefKind.None; 5699var whenTrue = node.WhenTrue.CheckAndUnwrapRefExpression(diagnostics, out var whenTrueRefKind); 5700var whenFalse = node.WhenFalse.CheckAndUnwrapRefExpression(diagnostics, out var whenFalseRefKind); 5702var isRef = whenTrueRefKind == RefKind.Ref && whenFalseRefKind == RefKind.Ref; 5705if (whenFalseRefKind == RefKind.Ref) 5710if (whenTrueRefKind == RefKind.Ref)

Binder\Binder_Query.cs (3)

707return lambdaBodyBinder.CreateBlockFromExpression(node, ImmutableArray<LocalSymbol>.Empty, RefKind.None, construction, null, d); 787return this.CreateBlockFromExpression(expression, locals, RefKind.None, result, expression, diagnostics); 829new 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)

533Debug.Assert(localSymbol.RefKind == RefKind.None || 547if (localSymbol.RefKind != RefKind.None) 564ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1243ImmutableArray<RefKind> refKinds; 1265AddLocalScopes(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)

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

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\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)

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 (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) 1883Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1944return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2171var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2200left.LocalSymbol.RefKind == RefKind.Ref && 2437public override RefKind RefKind 2439get { return RefKind.None; }

Compilation\CSharpCompilation.cs (5)

2282if (method.RefKind != RefKind.None) 4132RefKind returnRefKind, 4134ImmutableArray<RefKind> parameterRefKinds, 4167if (returnRefKind == RefKind.Out) 4307fields.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)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (8)

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

Emitter\Model\FieldSymbolAdapter.cs (1)

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

Emitter\Model\ParameterSymbolAdapter.cs (1)

41return AdaptedParameterSymbol.RefKind != RefKind.None;

Emitter\Model\ParameterTypeInformation.cs (1)

39return _underlyingParameter.RefKind != RefKind.None;

Emitter\Model\PEModuleBuilder.cs (1)

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

Emitter\Model\SpecializedFieldReference.cs (1)

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

FlowAnalysis\AbstractFlowPass.cs (37)

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

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

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

488method.RefKind == RefKind.None &&

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (1)

444refKinds: ImmutableArray<RefKind>.Empty,

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (2)

56if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None }) 311Debug.Assert(thisParameter is not { Type.IsValueType: true, RefKind: RefKind.Ref });

Lowering\ClosureConversion\ClosureConversion.cs (7)

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

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

139public override RefKind RefKind => RefKind.None;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

119if (RefKind == RefKind.RefReadOnly)

Lowering\DiagnosticsPass_ExpressionTrees.cs (5)

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

Lowering\DiagnosticsPass_Warnings.cs (5)

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

Lowering\ExtensionMethodReferenceRewriter.cs (7)

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

Lowering\Extensions.cs (3)

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

Lowering\InitializerRewriter.cs (2)

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

Lowering\Instrumentation\CompoundInstrumenter.cs (1)

168ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\Instrumenter.cs (1)

242ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (6)

307if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 453Debug.Assert(parameter.RefKind == RefKind.None); 553ImmutableArray<RefKind> argumentRefKindsOpt = NullableWalker.GetArgumentRefKinds(original.ArgumentRefKindsOpt, adjustForNewExtension, method, arguments.Length); 570private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds) 596if (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)

1092return ((BoundCall)expr).Method.RefKind != RefKind.None; 1095return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1098return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None; 1133symbol.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 (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)

566var 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.GetIsNewExtensionMember() && !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)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (11)

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

Lowering\LocalRewriter\LocalRewriter_Literal.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (2)

43ImmutableArray<RefKind> argumentRefKindsOpt = node.ArgumentRefKindsOpt; 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 (3)

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

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (7)

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

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (54)

Lowering\MethodToClassRewriter.cs (1)

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

Lowering\SpillSequenceSpiller.cs (42)

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

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) 286Debug.Assert(_reportedError || expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 287or BoundParameter { ParameterSymbol.RefKind: RefKind.None });

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (2)

64public override RefKind RefKind => RefKind.None;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)

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

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

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

Lowering\SynthesizedMethodBaseSymbol.cs (1)

140builder.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 (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)

789internal SynthesizedAttributeData? SynthesizeDynamicAttribute(TypeSymbol type, int customModifiersCount, RefKind refKindOpt = RefKind.None) 794if (type.IsDynamic() && refKindOpt == RefKind.None && customModifiersCount == 0) 903internal static ImmutableArray<TypedConstant> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount, TypeSymbol booleanType) 915internal static ImmutableArray<bool> Encode(TypeSymbol type, RefKind refKind, int customModifiersCount) 922internal static ImmutableArray<bool> EncodeWithoutCustomModifierFlags(TypeSymbol type, RefKind refKind) 929internal static void Encode(TypeSymbol type, int customModifiersCount, RefKind refKind, ArrayBuilder<bool> transformFlagsBuilder, bool addCustomModifierFlags) 933if (refKind != RefKind.None) 1024void handle(RefKind refKind, ImmutableArray<CustomModifier> customModifiers, TypeWithAnnotations twa) 1031if (refKind != RefKind.None) 1186return parameter.RefKind != RefKind.None; 1191return method.RefKind != RefKind.None; 1196return 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 && parameterType.TypeKind != TypeKind.Struct) 109if (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)

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

Symbols\MemberSignatureComparer.cs (14)

239/// the difference between <see cref="RefKind.Out"/> and <see cref="RefKind.Ref"/>. 541RefKind refKind1; 546RefKind refKind2; 771var refKind1 = param1.RefKind; 772var refKind2 = param2.RefKind; 787if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None)) 796static bool areRefKindsCompatible(RefKindCompareMode refKindCompareMode, RefKind refKind1, RefKind refKind2) 805return (refKind1, refKind2) is (RefKind.RefReadOnlyParameter, RefKind.In) or (RefKind.In, RefKind.RefReadOnlyParameter);

Symbols\MemberSymbolExtensions.cs (2)

318internal static ImmutableArray<RefKind> GetParameterRefKinds(this Symbol member) 327return 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; 1130case RefKind.None: 1131case RefKind.Ref: 1132case RefKind.In: 1133case RefKind.RefReadOnlyParameter: 1157foreach (var kind in this.ParameterRefKinds) 1161case RefKind.None: 1162case RefKind.In: 1164case RefKind.Out: 1165case RefKind.Ref: 1166case 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 1105bool filterIsReadOnlyAttribute = this.RefKind == RefKind.In; 1106bool 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)

364if ((thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) || 365(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)); 469RefKind 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)

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

Symbols\Source\GlobalExpressionVariable.cs (2)

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

Symbols\Source\LambdaParameterSymbol.cs (1)

23RefKind refKind,

Symbols\Source\LambdaSymbol.cs (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)

97public override RefKind RefKind

Symbols\Source\SourceComplexParameterSymbol.cs (10)

46RefKind refKind, 885return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 910if (this.RefKind == RefKind.RefReadOnlyParameter && this.IsOptional && this.ParameterSyntax.Default is null) 1423case RefKind.Ref: 1430case RefKind.Out: 1437case RefKind.In: 1444case RefKind.RefReadOnlyParameter: 1715RefKind refKind, 1741RefKind refKind, 1757Debug.Assert(refKind != RefKind.None || _refCustomModifiers.IsEmpty);

Symbols\Source\SourceConstructorSymbol.cs (1)

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

Symbols\Source\SourceDelegateMethodSymbol.cs (13)

28RefKind refKind, 56returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind); 218: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 221SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 222SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 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)

2237var refKind1 = method1.Parameters[i].RefKind; 2238var refKind2 = method2.Parameters[i].RefKind; 4467if (methodParam.RefKind != RefKind.None) 4490methodParams[0].RefKind == RefKind.None && 4883RefKind.Out 4885RefKind.None, 4931RefKind.None 4933RefKind.None, 4984RefKind.None)), 4985RefKind.None, 5040RefKind.None, 5119RefKind.None, 5214RefKind.None, 5245RefKind.None, 5311RefKind.None 5313RefKind.None, 5512_ = fieldSyntax.Declaration.Type.SkipScoped(out _).SkipRefInField(out var refKind); 5521var 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)

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

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (9)

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

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

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

Symbols\Source\SourceOrdinaryMethodSymbol.cs (6)

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) 863else if (IsPartial && !HasExplicitAccessModifier && Parameters.Any(static p => p.RefKind == RefKind.Out))

Symbols\Source\SourceParameterSymbol.cs (7)

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

Symbols\Source\SourceParameterSymbolBase.cs (2)

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

Symbols\Source\SourcePropertySymbolBase.cs (10)

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

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

24RefKind refKind, 36RefKind refKind,

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (8)

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

Symbols\Source\ThisParameterSymbol.cs (5)

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

Symbols\SubstitutedFieldSymbol.cs (1)

106public override RefKind RefKind => _underlyingField.RefKind;

Symbols\SymbolExtensions.cs (4)

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

27m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemStringType), 0, RefKind.None, name: "name"))));

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>), 414refKind: RefKind.None, 432refKind: RefKind.None, 526RefKind.None, 545TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 596argumentRefKindsOpt: default(ImmutableArray<RefKind>), 617RefKind.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; 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, 411internal override bool IsMetadataIn => RefKind is RefKind.In or RefKind.RefReadOnlyParameter || _baseParameterForAttributes?.IsMetadataIn == true; 413internal override bool IsMetadataOut => RefKind == RefKind.Out || _baseParameterForAttributes?.IsMetadataOut == true;

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

181public override RefKind RefKind

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedStaticConstructor.cs (2)

127public override RefKind RefKind 131return RefKind.None;

Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)

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

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

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

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

113public override RefKind RefKind

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

157public override RefKind RefKind => RefKind.None;

Symbols\Tuples\TupleFieldSymbol.cs (1)

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

Symbols\TypeSymbol.cs (3)

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

Symbols\UpdatedContainingSymbolLocal.cs (1)

79public override RefKind RefKind => _underlyingLocal.RefKind;

Symbols\VarianceSafety.cs (3)

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

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

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;