RefKind

Binder\Binder_AnonymousTypes.cs (1)

Binder\Binder_Attributes.cs (4)

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

Binder\Binder_Conversions.cs (9)

1447argumentRefKinds = argumentRefKinds.Add(RefKind.None); 1568if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 2122parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds); 3593{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 3637RefKind sourceRefKind, RefKind destinationRefKind, bool checkingReturns, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo) 3642: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 3647if (sourceRefKind != RefKind.None)

Binder\Binder_Crefs.cs (7)

288refKind: RefKind.None, 319refKind: RefKind.None, 1001refKind: RefKind.None, 1018refKind: RefKind.None, 1142RefKind refKind = parameter.RefKindKeyword.Kind().GetRefKind(); 1143if (refKind == RefKind.Ref && parameter.ReadOnlyKeyword.IsKind(SyntaxKind.ReadOnlyKeyword)) 1146refKind = RefKind.RefReadOnlyParameter;

Binder\Binder_Deconstruct.cs (2)

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

Binder\Binder_Expressions.cs (67)

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

301else if (analyzedArguments.RefKind(i) == RefKind.None) 308case RefKind.None: 309case RefKind.Ref: 320ImmutableArray<RefKind> refKinds = analyzedArguments.RefKinds.ToImmutableOrNull(); 555ImmutableArray<RefKind> refKinds, 574if (refKinds[argIndex] == RefKind.In) 1296if (receiverParameter.RefKind == RefKind.Ref) 1309analyzedArguments.RefKinds[0] = RefKind.Ref; 1312else if (receiverParameter.RefKind == RefKind.In) 1315Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1398CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1400if (extensionParameter.RefKind == RefKind.Ref) 1432if (receiver is BoundLocal { LocalSymbol: { RefKind: RefKind.None } local } && (local.IsUsing || local.IsForEach)) 1571ArrayBuilder<RefKind>? argumentRefKindsBuilder, 1656argumentRefKindsBuilder.Add(RefKind.None); 1681argumentRefKindsBuilder.Add(RefKind.None);

Binder\Binder_Lambda.cs (9)

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

Binder\Binder_Operators.cs (15)

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

Binder\Binder_Query.cs (3)

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

Binder\Binder_Statements.cs (48)

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

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

Binder\Binder.QueryUnboundLambdaState.cs (3)

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

Binder\Binder.ValueChecks.cs (120)

Binder\ExecutableCodeBinder.cs (3)

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

Binder\ForEachLoopBinder.cs (13)

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

Binder\InMethodBinder.cs (5)

118RefKind refKind = _methodSymbol.RefKind; 137RefKind refKind, TypeSymbol returnType, Location errorLocation, BindingDiagnosticBag diagnostics) 139if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType) 168internal static bool IsAsyncStreamInterface(CSharpCompilation compilation, RefKind refKind, TypeSymbol returnType) 170if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType)

Binder\LockBinder.cs (1)

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

Binder\RefSafetyAnalysis.cs (5)

608Debug.Assert(localSymbol.RefKind == RefKind.None || 622if (localSymbol.RefKind != RefKind.None) 639ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1348ImmutableArray<RefKind> refKinds; 1369AddLocalScopes(local, refEscapeScope: local.RefKind == RefKind.None ? _localScopeDepth : collectionEscape, valEscapeScope: collectionEscape);

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

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

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

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

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

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

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

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

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

46public RefKind RefKind 62return RefKind.None;

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

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

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

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

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

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

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

Binder\WithLambdaParametersBinder.cs (1)

47protected override TypeSymbol GetCurrentReturnType(out RefKind refKind)

BoundTree\BoundDagEvaluation.cs (2)

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

BoundTree\BoundExpression.cs (1)

557ImmutableArray<RefKind> newRefKinds,

BoundTree\BoundExpressionExtensions.cs (8)

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

BoundTree\BoundNewT.cs (1)

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

BoundTree\BoundNoPiaObjectCreationExpression.cs (1)

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

BoundTree\BoundObjectCreationExpression.cs (3)

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

BoundTree\BoundObjectCreationExpressionBase.cs (1)

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

BoundTree\BoundReturnStatement.cs (2)

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

BoundTree\Constructors.cs (17)

BoundTree\UnboundLambda.cs (52)

43internal readonly RefKind RefKind; 54RefKind refKind, 181ImmutableArray<RefKind> parameterRefKinds, 182RefKind refKind, 188parameterRefKinds.IsDefault ? Enumerable.Repeat(RefKind.None, parameterTypes.Length).ToImmutableArray() : parameterRefKinds, 219RefKind refKind = RefKind.None; 222RefKind rk = returnStatement.RefKind; 223if (rk != RefKind.None) 244Debug.Assert(refKind != RefKind.RefReadOnly); 410RefKind returnRefKind, 414ImmutableArray<RefKind> refKinds, 480public bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 505public RefKind RefKind(int index) { return Data.RefKind(index); } 595public abstract bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType); 602public abstract RefKind RefKind(int index); 677private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbol? invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers) 681refKind = CodeAnalysis.RefKind.None; 690internal (ImmutableArray<RefKind>, ArrayBuilder<ScopedKind>, ImmutableArray<TypeWithAnnotations>, bool) CollectParameterProperties() 692var parameterRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(ParameterCount); 699var refKind = RefKind(i); 757if (!HasExplicitReturnType(out var returnRefKind, refCustomModifiers: out _, out var returnType)) 823var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 847refKind == CodeAnalysis.RefKind.None && 869if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly) 936ImmutableArray<RefKind> parameterRefKinds, 937RefKind refKind, 953var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers); 986ImmutableArray<RefKind> parameterRefKinds) 988bool hasExplicitReturnType = HasExplicitReturnType(out var refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out var returnType); 1016Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1042Debug.Assert(refKind != CodeAnalysis.RefKind.RefReadOnly); 1052ImmutableArray<RefKind> parameterRefKinds, 1054RefKind refKind, 1091public readonly ImmutableArray<RefKind> ParameterRefKinds; 1094public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null); 1096private ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations> parameterTypes, ImmutableArray<RefKind> parameterRefKinds, NamedTypeSymbol? taskLikeReturnTypeOpt) 1157out ImmutableArray<RefKind> parameterRefKinds, 1163parameterRefKinds = ImmutableArray<RefKind>.Empty; 1172var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameterCount); 1248?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty)); 1265ImmutableArray<RefKind> parameterRefKinds) 1268var refKind = inferredReturnType.RefKind; 1282refKind = CodeAnalysis.RefKind.None; 1496private readonly RefKind _returnRefKind; 1503private readonly ImmutableArray<RefKind> _parameterRefKinds; 1512RefKind returnRefKind, 1519ImmutableArray<RefKind> parameterRefKinds, 1545public override bool HasExplicitReturnType(out RefKind refKind, out ImmutableArray<CustomModifier> refCustomModifiers, out TypeWithAnnotations returnType) 1606public override RefKind RefKind(int index) 1609return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1643statements[0] is BoundReturnStatement { RefKind: Microsoft.CodeAnalysis.RefKind.None, ExpressionOpt: BoundExpression expr })

CodeGen\CodeGenerator_HasHome.cs (19)

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

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

CodeGen\EmitAddress.cs (13)

37Debug.Assert(((BoundDup)expression).RefKind != RefKind.None, "taking address of a stack value?"); 130var funcPtrRefKind = funcPtrInvocation.FunctionPointer.Signature.RefKind; 131if (funcPtrRefKind == RefKind.Ref || 132(IsAnyReadOnly(addressKind) && funcPtrRefKind == RefKind.RefReadOnly)) 197var methodRefKind = call.Method.RefKind; 198return methodRefKind == RefKind.Ref || 199(IsAnyReadOnly(addressKind) && methodRefKind == RefKind.RefReadOnly); 298if (local.RefKind != RefKind.None) 399Debug.Assert(symbol.RefKind == RefKind.None, "No test coverage for the scenario."); 400if (symbol.RefKind == RefKind.None && topSequence.Locals.Contains(symbol)) 536if (parameterSymbol.RefKind == RefKind.None) 609AddressKind receiverAddressKind = field.RefKind == RefKind.None ? 637_builder.EmitOpCode(field.RefKind == RefKind.None ? ILOpCode.Ldflda : ILOpCode.Ldfld);

CodeGen\EmitExpression.cs (63)

CodeGen\EmitStatement.cs (10)

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 && 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"); 1232if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1266private ImmutableArray<BoundExpression> VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt) 1276RefKind argRefKind = CodeGenerator.GetArgumentRefKind(arguments, parameters, argRefKindsOpt, i); 1283private void VisitArgument(ImmutableArray<BoundExpression> arguments, ref ArrayBuilder<BoundExpression> rewrittenArguments, int i, RefKind argRefKind) 1285ExprContext context = (argRefKind == RefKind.None) ? ExprContext.Value : ExprContext.Address; 1307ImmutableArray<RefKind> argRefKindsOpt = node.ArgumentRefKindsOpt; 1311RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1439if (localSym.RefKind == RefKind.None) 1893Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1954return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2230var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2496public override RefKind RefKind 2498get { return RefKind.None; }

Compilation\CSharpCompilation.cs (5)

2333if (method.RefKind != RefKind.None) 4265RefKind returnRefKind, 4267ImmutableArray<RefKind> parameterRefKinds, 4300if (returnRefKind == RefKind.Out) 4440fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None));

Compiler\ClsComplianceChecker.cs (2)

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

Compiler\MethodBodySynthesizer.cs (5)

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

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (8)

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

Emitter\Model\FieldSymbolAdapter.cs (1)

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

Emitter\Model\ParameterSymbolAdapter.cs (1)

41return AdaptedParameterSymbol.RefKind != RefKind.None;

Emitter\Model\ParameterTypeInformation.cs (1)

39return _underlyingParameter.RefKind != RefKind.None;

Emitter\Model\PEModuleBuilder.cs (1)

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

Emitter\Model\SpecializedFieldReference.cs (1)

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

FlowAnalysis\AbstractFlowPass.cs (37)

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

356NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 820write: field.RefKind == RefKind.None || isRef); 933write: field.RefKind == RefKind.None || isRef); 1196((ParameterSymbol)symbol).RefKind == RefKind.Out) 1296if (fieldSymbol.RefKind != RefKind.None) 1480if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess) 1533if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 1584if (isRef && param.RefKind == RefKind.Out) 1602write: field.RefKind == RefKind.None || isRef); 1776if (parameter.RefKind != RefKind.Out) 1788if (thisParameter.RefKind != RefKind.Out) 1800if (extensionParameter.RefKind != RefKind.Out) 1823if (current is not MethodSymbol && parameter.RefKind == RefKind.Out) 1853if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async 1861NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1919if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor) 1931if (parameter.RefKind != RefKind.None) 2591WriteArgument(operand, RefKind.Out, null); 2595protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method) 2597if (refKind == RefKind.Ref) 2611if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2803NoteWrite(iterationVariable, null, read: true, isRef: iterationVariable.RefKind != RefKind.None);

FlowAnalysis\FlowAnalysisPass.cs (3)

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

FlowAnalysis\NullableWalker.cs (70)

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

Lowering\AsyncRewriter\AsyncExceptionHandlerRewriter.cs (1)

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

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

488method.RefKind == RefKind.None &&

Lowering\AsyncRewriter\AsyncMethodToStateMachineRewriter.cs (1)

444refKinds: ImmutableArray<RefKind>.Empty,

Lowering\AsyncRewriter\RuntimeAsyncRewriter.cs (3)

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

Lowering\ClosureConversion\ClosureConversion.cs (7)

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

Lowering\ClosureConversion\LambdaCapturedVariable.cs (2)

139public override RefKind RefKind => RefKind.None;

Lowering\ClosureConversion\SynthesizedClosureMethod.cs (1)

119if (RefKind == RefKind.RefReadOnly)

Lowering\DiagnosticsPass_ExpressionTrees.cs (5)

310ImmutableArray<RefKind> argumentRefKindsOpt, 358else if (method.RefKind != RefKind.None) 555VisitCall(node.AddMethod, null, node.Arguments, default(ImmutableArray<RefKind>), default(ImmutableArray<string>), default(ImmutableArray<int>), node.DefaultArguments, node); 585if (_inExpressionLambda && property.RefKind != RefKind.None) 627if (p.RefKind != RefKind.None && p.TryGetFirstLocation() is Location location)

Lowering\DiagnosticsPass_Warnings.cs (5)

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

Lowering\ExtensionMethodReferenceRewriter.cs (7)

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

Lowering\Extensions.cs (3)

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

Lowering\InitializerRewriter.cs (2)

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

Lowering\Instrumentation\CompoundInstrumenter.cs (1)

168ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\Instrumenter.cs (1)

242ref ImmutableArray<RefKind> argumentRefKindsOpt)

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (6)

309if (parameter.RefKind == RefKind.Out || parameter.IsDiscard) 455Debug.Assert(parameter.RefKind == RefKind.None); 557ImmutableArray<RefKind> argumentRefKindsOpt = NullableWalker.AdjustArgumentRefKindsIfNeeded(original.ArgumentRefKindsOpt, adjustForExtensionBlockMethod, method, arguments.Length); 574private BoundExpression InstrumentCall(BoundExpression invocation, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds) 600if (refKinds[i] is not (RefKind.Ref or RefKind.Out))

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (4)

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

Lowering\IteratorRewriter\IteratorConstructor.cs (1)

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

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_AnonymousObjectCreation.cs (1)

28argumentRefKindsOpt: default(ImmutableArray<RefKind>),

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (7)

155ImmutableArray<RefKind> refKinds, 204default(ImmutableArray<RefKind>), 239Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None); 316ImmutableArray<RefKind> argumentRefKindsOpt, 349(arguments.Length != 0 || !IsSafeForReordering(rewrittenRight, RefKind.None))) 389if (!IsSafeForReordering(rewrittenRight, RefKind.None)) 391BoundLocal capturedRight = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);

Lowering\LocalRewriter\LocalRewriter_Call.cs (109)

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (29)

234BoundLocal binaryResult = _factory.StoreToTemp(opFinal, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 259return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false }; 295RefKind refKind; 300Debug.Assert(refKind != RefKind.Ref || 321refKind = RefKind.None; 325refKind = variableRepresentsLocation ? RefKind.Ref : RefKind.None; 333if (refKind == RefKind.Ref && 349refKind: refKind is RefKind.RefReadOnlyParameter ? RefKind.In : refKind); 473ImmutableArray<RefKind> argumentRefKinds = indexerAccess.ArgumentRefKindsOpt; 505ref ImmutableArray<RefKind> argumentRefKinds, 512ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 585Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None); 611var variableTemp = _factory.StoreToTemp(arrayAccess, out assignmentToTemp, refKind: RefKind.Ref); 689var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 760if (propertyAccess.PropertySymbol.RefKind == RefKind.None) 775if (indexerAccess.GetRefKind() == RefKind.None) 788if (implicitIndexerAccess.GetRefKind() == RefKind.None) 841Debug.Assert(originalLHS.GetRefKind() == RefKind.Ref); 862Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 866Debug.Assert(((BoundFunctionPointerInvocation)originalLHS).FunctionPointer.Signature.RefKind != RefKind.None); 917var variableTemp = _factory.StoreToTemp(rewrittenVariable, out assignmentToTemp2, refKind: RefKind.Ref); 1018((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None || 1022return localsMayBeAssignedOrCaptured || ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None;

Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (5)

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

Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (19)

55ImmutableArray<RefKind> refKinds) 109ImmutableArray<RefKind> argumentRefKindsOpt, 121if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 332possiblyRefCapturedReceiver = _factory.StoreToTemp(possiblyRefCapturedReceiver, out var refCapture, createSpan.Parameters[0].RefKind == RefKind.In ? RefKindExtensions.StrictIn : RefKind.Ref); 508Debug.Assert(!isLeftOfAssignment || node.IndexerOrSliceAccess.GetRefKind() == RefKind.Ref); 569RefKind refKind = receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref; 573if (refKind == RefKind.Ref && 608if ((capturedReceiver is BoundArrayAccess && !IsSafeForReordering(makeOffsetInput, RefKind.None)) || 679if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 918RefKind refKind = receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref; 922if (refKind == RefKind.Ref && 1185if (startMakeOffsetInput is not null && !IsSafeForReordering(startMakeOffsetInput, RefKind.None)) 1190if (endMakeOffsetInput is not null && !IsSafeForReordering(endMakeOffsetInput, RefKind.None)) 1195if (rewrittenRangeArg is not null && !IsSafeForReordering(rewrittenRangeArg, RefKind.None))

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)

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

Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_ObjectCreationExpression.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (13)

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

Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (2)

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

Lowering\LocalRewriter\LocalRewriter_StringConcat.cs (4)

490readOnlySpanCtorRefParamGeneric.Parameters[0].RefKind != RefKind.Out) 528Debug.Assert(readOnlySpanCtorRefParamChar.Parameters[0].RefKind != RefKind.Out); 535argumentRefKindsOpt: [readOnlySpanCtorRefParamChar.Parameters[0].RefKind == RefKind.Ref ? RefKind.Ref : RefKindExtensions.StrictIn],

Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (3)

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

Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (1)

512ImmutableArray<RefKind> argumentRefKindsOpt = default;

Lowering\LocalRewriter\LocalRewriter.cs (6)

1099return ((BoundCall)expr).Method.RefKind != RefKind.None; 1102return ((BoundFunctionPointerInvocation)expr).FunctionPointer.Signature.RefKind != RefKind.None; 1105return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1108return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None; 1135return ((BoundDup)expr).RefKind != RefKind.None; 1149symbol.Parameters.Any(static p => p.RefKind == RefKind.In))

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

163var refKindBuilder = ArrayBuilder<RefKind>.GetInstance(); 166void addArg(RefKind refKind, BoundExpression expression) 188addArg(RefKind.Out, _tempAllocator.GetTemp(outputTemp)); 555&& loweredInput.GetRefKind() == RefKind.None &&

Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (54)

Lowering\MethodToClassRewriter.cs (1)

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

Lowering\SpillSequenceSpiller.cs (43)

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 }, 550Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 554Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 575if (valueTypeReceiverLocal is { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } 576&& originalReceiver is BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } originalReceiverLocal 586&& receiverRefLocal.RefKind == RefKind.Ref 634ImmutableArray<RefKind> refKinds = default(ImmutableArray<RefKind>), 682var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 970left = Spill(leftBuilder, VisitExpression(ref leftBuilder, left), RefKind.Ref); 1014receiver = Spill(leftBuilder, VisitExpression(ref leftBuilder, field.ReceiverOpt), RefKind.Ref); 1032expression = Spill(builder, expression, RefKind.None); 1102RefKind refKind = ReceiverSpillRefKind(receiver); 1104Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1106if (refKind == RefKind.Ref && 1119if (refKind != RefKind.None && 1155private static RefKind ReceiverSpillRefKind(BoundExpression receiver) 1157var result = RefKind.None; 1160result = receiver.Type.IsReadOnly ? RefKind.In : RefKind.Ref; 1349var receiverRefKind = ReceiverSpillRefKind(node.Receiver); 1370if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1373receiver = Spill(receiverBuilder, receiver, RefKind.None); 1388receiver = Spill(receiverBuilder, receiver, RefKind.Ref); 1390var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (6)

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

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)

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

Lowering\StateMachineRewriter\RefInitializationHoister.cs (23)

85Debug.Assert(local.RefKind != RefKind.None); 138RefKind refKind, 156refKind: RefKind.None, 172refKind: RefKind.None, 193if (refKind != RefKind.None || field.FieldSymbol.IsReadOnly) return expr; 198if (refKind == RefKind.None) 208refKind: isFieldOfStruct ? refKind : RefKind.None, 239if (refKind != RefKind.None && refKind != RefKind.In) 241Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.Out); 242if (call.Method.RefKind != RefKind.None) 249refKind = RefKind.None; 260if (refKind != RefKind.None && refKind != RefKind.RefReadOnly) 262Debug.Assert(refKind is RefKindExtensions.StrictIn or RefKind.Ref or RefKind.In); 268refKind = RefKind.None; 277if (refKind != RefKind.None) 286Debug.Assert(_reportedError || expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 287or BoundParameter { ParameterSymbol.RefKind: RefKind.None }); 291if (expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 292or BoundParameter { ParameterSymbol.RefKind: RefKind.None })

Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (2)

64public override RefKind RefKind => RefKind.None;

Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)

175if (local.RefKind != RefKind.None) 183Debug.Assert(local.RefKind == RefKind.None);

Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (2)

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

Lowering\SynthesizedMethodBaseSymbol.cs (1)

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

Lowering\SyntheticBoundNodeFactory.cs (30)

580Debug.Assert(CurrentFunction.RefKind == RefKind.None); 585return new BoundReturnStatement(Syntax, CurrentFunction.RefKind != RefKind.None ? RefKind.Ref : RefKind.None, expression, @checked: false) { WasCompilerGenerated = true }; 605RefKind refKind = RefKind.None, 645return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 804public BoundObjectCreationExpression New(MethodSymbol constructor, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKinds) 914public static ImmutableArray<RefKind> ArgumentRefKindsFromParameterRefKinds(MethodSymbol method, bool useStrictArgumentRefKinds) 918if (!result.IsDefaultOrEmpty && (result.Contains(RefKind.RefReadOnlyParameter) || 919(useStrictArgumentRefKinds && result.Contains(RefKind.In)))) 921var builder = ArrayBuilder<RefKind>.GetInstance(result.Length); 923foreach (var refKind in result) 934public static RefKind ArgumentRefKindFromParameterRefKind(RefKind refKind, bool useStrictArgumentRefKinds) 938RefKind.In or RefKind.RefReadOnlyParameter when useStrictArgumentRefKinds => RefKindExtensions.StrictIn, 939RefKind.RefReadOnlyParameter => RefKind.In, 944public BoundCall Call(BoundExpression? receiver, MethodSymbol method, ImmutableArray<RefKind> refKinds, ImmutableArray<BoundExpression> args) 1673RefKind refKind = RefKind.None, 1690case RefKind.Out: 1691refKind = RefKind.Ref; 1694case RefKind.In: 1703Debug.Assert(argument.GetRefKind() != RefKind.In); 1704refKind = RefKind.None; 1708case RefKind.None: 1709case RefKind.Ref: 1740isRef: refKind != RefKind.None);

Operations\CSharpOperationFactory.cs (6)

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

SymbolDisplay\SymbolDisplayVisitor.cs (1)

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

SymbolDisplay\SymbolDisplayVisitor.Members.cs (9)

39case RefKind.Ref: 42case RefKind.RefReadOnly: 852symbol.RefKind != RefKind.Out && 873symbol.RefKind == RefKind.None && 1148private void AddParameterRefKind(RefKind refKind) 1152case RefKind.Out: 1156case RefKind.Ref: 1160case RefKind.In: 1164case RefKind.RefReadOnlyParameter:

Symbols\AnonymousTypes\AnonymousTypeField.cs (2)

23public readonly RefKind RefKind; 40RefKind refKind,

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

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

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

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

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

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

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

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

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

35public override RefKind RefKind => RefKind.None;

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

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

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

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

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

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

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

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

Symbols\BaseTypeAnalysis.cs (1)

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

Symbols\Compilation_WellKnownMembers.cs (13)

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

Symbols\ErrorMethodSymbol.cs (2)

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

Symbols\ErrorPropertySymbol.cs (2)

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

Symbols\Extensions\SynthesizedExtensionMarker.cs (6)

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

Symbols\FieldSymbol.cs (2)

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

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (48)

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

Symbols\FunctionPointers\FunctionPointerParameterSymbol.cs (5)

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

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (13)

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

Symbols\LocalSymbol.cs (2)

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

Symbols\MemberSignatureComparer.cs (14)

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

Symbols\MemberSymbolExtensions.cs (2)

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

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

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

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

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

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

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

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

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

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

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

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

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

Symbols\MethodSymbol.cs (8)

227return this.RefKind == RefKind.Ref; 238Debug.Assert(this.RefKind != RefKind.Out); 239return this.RefKind == RefKind.RefReadOnly; 246public abstract RefKind RefKind { get; } 400return receiverParameter is { Type.IsValueType: true, RefKind: RefKind.In or RefKind.RefReadOnlyParameter or RefKind.None }; 951internal ImmutableArray<RefKind> ParameterRefKinds

Symbols\NamedTypeSymbol.cs (12)

436if (thisParam.RefKind == RefKind.Ref && !thisParam.Type.IsValueType) 441if (thisParam.RefKind is RefKind.In or RefKind.RefReadOnlyParameter 2197RefKind: RefKind.None, 2199Parameters: [{ RefKind: RefKind.In or RefKind.None }] 2398return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] }; 2482RefKind: RefKind.None, 2667RefKind: RefKind.None, 2856RefKind: RefKind.None, 2857Parameters: [{ RefKind: RefKind.Out }],

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)

60public abstract RefKind RefKind { get; } 166RefKind refKind; 168((refKind = RefKind) == RefKind.None || 169(refKind is RefKind.In or RefKind.RefReadOnlyParameter) || 170(refKind == RefKind.Ref && ContainingSymbol.ContainingType.IsComImport)); 476RefKind IParameterSymbolInternal.RefKind => RefKind;

Symbols\PropertySymbol.cs (4)

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

Symbols\PropertySymbolExtensions.cs (2)

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

Symbols\PublicModel\FieldSymbol.cs (1)

34RefKind IFieldSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\LocalSymbol.cs (1)

52RefKind ILocalSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\MethodSymbol.cs (1)

341RefKind IMethodSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\ParameterSymbol.cs (1)

59RefKind IParameterSymbol.RefKind => _underlying.RefKind;

Symbols\PublicModel\PropertySymbol.cs (1)

110RefKind IPropertySymbol.RefKind => _underlying.RefKind;

Symbols\ReducedExtensionMethodSymbol.cs (1)

490public override RefKind RefKind

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)

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

Symbols\Source\GlobalExpressionVariable.cs (2)

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

Symbols\Source\LambdaParameterSymbol.cs (1)

23RefKind refKind,

Symbols\Source\LambdaSymbol.cs (9)

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

Symbols\Source\LocalFunctionSymbol.cs (5)

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

Symbols\Source\ParameterHelpers.cs (36)

Symbols\Source\SourceAssemblySymbol.cs (1)

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

Symbols\Source\SourceClonedParameterSymbol.cs (1)

97public override RefKind RefKind

Symbols\Source\SourceComplexParameterSymbol.cs (10)

46RefKind refKind, 905return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 930if (this.RefKind == RefKind.RefReadOnlyParameter && this.IsOptional && this.ParameterSyntax.Default is null) 1459case RefKind.Ref: 1466case RefKind.Out: 1473case RefKind.In: 1480case RefKind.RefReadOnlyParameter: 1762RefKind refKind, 1788RefKind refKind, 1804Debug.Assert(refKind != RefKind.None || _refCustomModifiers.IsEmpty);

Symbols\Source\SourceConstructorSymbol.cs (1)

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

Symbols\Source\SourceDelegateMethodSymbol.cs (13)

29RefKind refKind, 57returnTypeSyntax = returnTypeSyntax.SkipScoped(out _).SkipRefInLocalOrReturn(diagnostics, out RefKind refKind); 223: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 226SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 227SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 265RefKind refKind, 288if (this.RefKind == RefKind.RefReadOnly) 327if (this.RefKind == RefKind.RefReadOnly) 363: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 373parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 374parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 412if (p.RefKind != RefKind.None) 419parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));

Symbols\Source\SourceDestructorSymbol.cs (1)

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

Symbols\Source\SourceEnumConstantSymbol.cs (2)

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

Symbols\Source\SourceEventAccessorSymbol.cs (1)

37RefKind.None,

Symbols\Source\SourceFieldSymbol.cs (1)

139if (RefKind == RefKind.RefReadOnly)

Symbols\Source\SourceLocalSymbol.cs (3)

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

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (19)

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

Symbols\Source\SourceMemberContainerSymbol.cs (18)

Symbols\Source\SourceMemberFieldSymbol.cs (13)

371internal readonly RefKind RefKind; 374internal TypeAndRefKind(RefKind refKind, TypeWithAnnotations type) 466public sealed override RefKind RefKind => GetTypeAndRefKind(ConsList<FieldSymbol>.Empty).RefKind; 496RefKind refKind = RefKind.None; 534Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 536if (refKind != RefKind.None) 552type = binder.BindTypeOrVarKeyword(typeSyntax.SkipScoped(out _).SkipRefInField(out RefKind refKindToAssert), diagnostics, out isVar); 553Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error 584var initializerOpt = executableBinder.BindInferredVariableInitializer(diagnostics, RefKind.None, syntaxNode, declarator); 613if (refKind != RefKind.None)

Symbols\Source\SourceMemberMethodSymbol.cs (6)

131public RefKind RefKind 133get { return (RefKind)((_flags >> RefKindOffset) & RefKindMask); } 189RefKind refKind, 235RefKind refKind, 423RefKind refKind, 1133public sealed override RefKind RefKind => this.flags.RefKind;

Symbols\Source\SourceMethodSymbol.cs (1)

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

Symbols\Source\SourceMethodSymbolWithAttributes.cs (4)

785if (param.RefKind == RefKind.Out) 1417static void checkAndReportManagedTypes(TypeSymbol type, RefKind refKind, SyntaxNode syntax, bool isParam, BindingDiagnosticBag diagnostics) 1419if (refKind != RefKind.None) 1542if (this.RefKind != RefKind.None)

Symbols\Source\SourceNamedTypeSymbol_Extension.cs (9)

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

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (2)

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

Symbols\Source\SourceOrdinaryMethodSymbol.cs (6)

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

Symbols\Source\SourceParameterSymbol.cs (7)

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

Symbols\Source\SourceParameterSymbolBase.cs (2)

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

Symbols\Source\SourcePropertySymbolBase.cs (10)

60private readonly RefKind _refKind; 99RefKind refKind, 252_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 271else if (_refKind == RefKind.RefReadOnly) 360public sealed override RefKind RefKind 889if (RefKind != RefKind.None && IsRequired) 913if (this.RefKind != RefKind.None) 960if (_refKind != RefKind.None) 994else if (RefKind != RefKind.None) 1072if (_refKind == RefKind.RefReadOnly)

Symbols\Source\SourceSimpleParameterSymbol.cs (2)

24RefKind refKind, 36RefKind refKind,

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (8)

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

Symbols\Source\ThisParameterSymbol.cs (5)

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

Symbols\SubstitutedFieldSymbol.cs (1)

108public override RefKind RefKind => _underlyingField.RefKind;

Symbols\SymbolExtensions.cs (4)

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

34public 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)

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

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

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

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

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

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

41RefKind.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); 128public override RefKind RefKind => _property.RefKind;

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (7)

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

Symbols\Synthesized\SynthesizedEmbeddedAttributePropertySymbol.cs (4)

27public override RefKind RefKind => RefKind.None; 90public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedMemorySafetyRulesAttributeSymbol.cs (1)

66refKind: RefKind.None,

Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)

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

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (11)

115public override RefKind RefKind 117get { return RefKind.None; } 304default(ImmutableArray<RefKind>), 372argumentRefKindsOpt: default(ImmutableArray<RefKind>), 398argumentRefKindsOpt: default(ImmutableArray<RefKind>), 451refKind: RefKind.None, 469refKind: RefKind.None, 563RefKind.None, 582TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 633argumentRefKindsOpt: default(ImmutableArray<RefKind>), 654RefKind.None,

Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (2)

31public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedFieldSymbol.cs (2)

36public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedHotReloadExceptionConstructorSymbol.cs (3)

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

Symbols\Synthesized\SynthesizedImplementationMethod.cs (1)

96public sealed override RefKind RefKind

Symbols\Synthesized\SynthesizedInlineArrayAsReadOnlySpanMethod.cs (2)

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

Symbols\Synthesized\SynthesizedInlineArrayAsSpanMethod.cs (4)

18this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(TypeParameters[0]), 0, RefKind.Ref, "buffer"), 19SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "length"))); 51Debug.Assert(inlineArrayParameter.RefKind is RefKind.Ref or RefKind.In);

Symbols\Synthesized\SynthesizedInlineArrayElementRefMethod.cs (4)

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

Symbols\Synthesized\SynthesizedInlineArrayElementRefReadOnlyMethod.cs (4)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefMethod.cs (3)

Symbols\Synthesized\SynthesizedInlineArrayFirstElementRefReadOnlyMethod.cs (3)

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

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

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (2)

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

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (6)

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

Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (2)

38public override RefKind RefKind => RefKind.None;

Symbols\Synthesized\SynthesizedLocal.cs (5)

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

Symbols\Synthesized\SynthesizedParameterSymbol.cs (14)

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

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

181public override RefKind RefKind

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedStaticConstructor.cs (2)

127public override RefKind RefKind 131return RefKind.None;

Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)

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

Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)

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

Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)

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

Symbols\Synthesized\SynthesizedUnionCtor.cs (1)

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

Symbols\Synthesized\SynthesizedUnionValuePropertySymbol.cs (1)

36RefKind.None,

Symbols\Synthesized\TypeSubstitutedLocalSymbol.cs (1)

113public override RefKind RefKind

Symbols\Tuples\TupleErrorFieldSymbol.cs (2)

159public override RefKind RefKind => RefKind.None;

Symbols\Tuples\TupleFieldSymbol.cs (1)

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

Symbols\TypeSymbol.cs (3)

2029RefKind interfaceMemberRefKind = RefKind.None; 2589return elementField is { RefKind: RefKind.None, IsFixedSizeBuffer: false };

Symbols\UpdatedContainingSymbolLocal.cs (1)

79public override RefKind RefKind => _underlyingLocal.RefKind;

Symbols\VarianceSafety.cs (3)

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

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

58public override RefKind RefKind

Symbols\Wrapped\WrappedParameterSymbol.cs (1)

44public sealed override RefKind RefKind

Symbols\Wrapped\WrappedPropertySymbol.cs (1)

49public override RefKind RefKind

Syntax\SyntaxNodeExtensions.cs (11)

223internal static RefKind GetRefKindInLocalOrReturn(this TypeSyntax syntax, BindingDiagnosticBag diagnostics) 225syntax.SkipRefInLocalOrReturn(diagnostics, out var refKind); 239internal static TypeSyntax SkipRefInField(this TypeSyntax syntax, out RefKind refKind) 246internal static TypeSyntax SkipRefInLocalOrReturn(this TypeSyntax syntax, BindingDiagnosticBag? diagnostics, out RefKind refKind) 249private static TypeSyntax SkipRefWorker(TypeSyntax syntax, BindingDiagnosticBag? diagnostics, out RefKind refKind) 255? RefKind.RefReadOnly 256: RefKind.Ref; 284refKind = RefKind.None; 321out RefKind refKind) 325refKind = RefKind.None; 331refKind = RefKind.Ref;