src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
544case RefKind.Out:
551case RefKind.Ref:
src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)
76refKind: RefKind.None,
src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)
254refKind: RefKind.None,
src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (8)
144document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None));
158document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None));
172document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None));
220parameter.RefKind is RefKind.Out ||
245private static RefKind GetRefKindFromContext(State state)
249return RefKind.Ref;
253return RefKind.RefReadOnly;
257return RefKind.None;
src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateParameterCodeAction.cs (1)
49RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
Binder\Binder.ValueChecks.cs (122)
54Method is { RefKind: not RefKind.None, ReturnType: { } returnType } &&
130public ImmutableArray<RefKind> ArgumentRefKindsOpt;
263public static MethodInvocationInfo FromInlineArrayConversion(SignatureOnlyMethodSymbol equivalentSignatureMethod, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds, bool hasAnyErrors)
309public static MethodInvocationInfo FromInlineArrayAccess(SignatureOnlyMethodSymbol equivalentSignatureMethod, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKinds, bool hasAnyErrors)
405internal RefKind RefKind { get; }
407internal EscapeArgument(ParameterSymbol? parameter, BoundExpression argument, RefKind refKind, bool isArgList = false)
415public void Deconstruct(out ParameterSymbol? parameter, out BoundExpression argument, out RefKind refKind)
614if (indexerAccess.Indexer.RefKind != RefKind.None)
637var useSetAccessor = coreValueKind == BindValueKind.Assignable && indexerAccess.Indexer.RefKind != RefKind.Ref;
646ArrayBuilder<RefKind>? refKindsBuilderOpt;
649refKindsBuilderOpt = ArrayBuilder<RefKind>.GetInstance(accessorForDefaultArguments.ParameterCount);
1286if (localSymbol.RefKind == RefKind.RefReadOnly ||
1287(localSymbol.RefKind == RefKind.None && !localSymbol.IsWritableVariable))
1295if (localSymbol.RefKind == RefKind.None)
1327if (localSymbol.RefKind == RefKind.None)
1368if (parameterSymbol.RefKind is RefKind.In or RefKind.RefReadOnlyParameter && RequiresAssignableVariable(valueKind))
1373else if (parameterSymbol.RefKind == RefKind.None && RequiresRefAssignableVariable(valueKind))
1379Debug.Assert(parameterSymbol.RefKind != RefKind.None || !RequiresRefAssignableVariable(valueKind));
1383if (parameterSymbol.RefKind == RefKind.None &&
1387Debug.Assert(backingField.RefKind == RefKind.None);
1392Debug.Assert(backingField.RefKind == RefKind.None);
1482{ RefKind: RefKind.Out, UseUpdatedEscapeRules: true } => SafeContext.ReturnOnly,
1494{ RefKind: RefKind.None } => SafeContext.CurrentMethod,
1496{ HasUnscopedRefAttribute: true, UseUpdatedEscapeRules: true, RefKind: RefKind.Out } => SafeContext.ReturnOnly,
1529Debug.Assert(parameterSymbol.RefKind == RefKind.None || isRefScoped || refSafeToEscape.IsReturnOnly);
1579if ((fieldSymbol.RefKind == RefKind.None ? RequiresAssignableVariable(valueKind) : RequiresRefAssignableVariable(valueKind)) &&
1591case RefKind.None:
1593case RefKind.Ref:
1595case RefKind.RefReadOnly:
1615case RefKind.None:
1618case RefKind.Ref:
1619case RefKind.RefReadOnly:
1639case RefKind.None:
1641case RefKind.Ref:
1642case RefKind.RefReadOnly:
1742if (fieldSymbol.RefKind != RefKind.None)
1766if (fieldSymbol.RefKind != RefKind.None)
1902if (RequiresVariable(valueKind) && methodSymbol.RefKind == RefKind.None)
1917if (RequiresAssignableVariable(valueKind) && methodSymbol.RefKind == RefKind.RefReadOnly)
1948propertySymbol.RefKind == RefKind.None)
1972if (RequiresAssignableVariable(valueKind) && propertySymbol.RefKind == RefKind.RefReadOnly)
1978var requiresSet = RequiresAssignableVariable(valueKind) && propertySymbol.RefKind == RefKind.None;
2047var requiresGet = !RequiresAssignmentOnly(valueKind) || propertySymbol.RefKind != RefKind.None;
2314(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) &&
2394result.ArgumentRefKindsOpt = [RefKind.None, .. methodInvocationInfo.ArgumentRefKindsOpt];
2482var valid = effectiveRefKind != RefKind.None && isRefEscape ?
2545(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) &&
2677var refKind = parameter?.RefKind ?? RefKind.None;
2682if (refKind == RefKind.None &&
2683parameter?.RefKind is RefKind.In or RefKind.RefReadOnlyParameter)
2718if (getArgument.RefKind == RefKind.Ref)
2724if (setArgument.RefKind == RefKind.Ref)
2740return new EscapeArgument(parameter: null, receiver, RefKind.None);
2743var refKind = RefKind.None;
2763ImmutableArray<RefKind> argRefKindsOpt,
2770var refKind = argRefKindsOpt.IsDefault ? RefKind.None : argRefKindsOpt[argIndex];
2773if (refKind == RefKind.Ref && mixableArguments is not null)
2912return parameter.RefKind == RefKind.Ref &&
2983if (refKind != RefKind.None)
2996if (parameter.Type.IsRefLikeOrAllowsRefLikeType() && parameter.RefKind != RefKind.Out && GetParameterValEscapeLevel(parameter) is { } valEscapeLevel)
3003if (parameter.RefKind != RefKind.None && GetParameterRefEscapeLevel(parameter) is { } refEscapeLevel)
3067if (parameter.RefKind != RefKind.None && !parameter.IsThis)
3340Debug.Assert(underlyingParameter.RefKind != RefKind.Out); // Shouldn't get here for a constructor
3350public override RefKind RefKind
3354if (_underlyingParameter.RefKind is not RefKind.None and var underlyingRefKind)
3361return RefKind.None;
3366return RefKind.Ref;
3576Debug.Assert(field.RefKind == RefKind.None ? RequiresAssignableVariable(kind) : RequiresRefAssignableVariable(kind));
3778if (methodSymbol.RefKind == RefKind.None)
3794if (methodSymbol.RefKind == RefKind.None)
3842if (methodSymbol.RefKind == RefKind.None)
3863Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None);
3868ImmutableArray<RefKind> refKinds;
3871Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None);
3903conversion.Conversion.Method.RefKind == RefKind.None));
3910unaryMethod.RefKind == RefKind.None));
3917binaryMethod.RefKind == RefKind.None));
3923logicalOperator.LogicalOperator.RefKind == RefKind.None));
3930compoundMethod.RefKind == RefKind.None));
3937incrementMethod.RefKind == RefKind.None));
4070if (methodSymbol.RefKind == RefKind.None)
4090if (indexerSymbol.RefKind == RefKind.None)
4115if (indexerSymbol.RefKind == RefKind.None)
4140if (methodSymbol.RefKind == RefKind.None)
4165Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None);
4170ImmutableArray<RefKind> refKinds;
4173Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None);
4189if (signature.RefKind == RefKind.None)
4207if (propertySymbol.RefKind == RefKind.None)
4248conversion.Conversion.Method.RefKind == RefKind.None);
4255unaryMethod.RefKind == RefKind.None));
4262binaryMethod.RefKind == RefKind.None));
4268logicalOperator.LogicalOperator.RefKind == RefKind.None));
4275compoundMethod.RefKind == RefKind.None));
4282incrementMethod.RefKind == RefKind.None));
4506ImmutableArray<RefKind> refKinds;
4595ImmutableArray<RefKind> refKinds;
4793if (constructMethod is not { Parameters: [{ RefKind: RefKind.None } parameter] })
4952var accessorKind = property.RefKind == RefKind.None ? AccessorKind.Set : AccessorKind.Get;
5217ImmutableArray<RefKind> refKinds;
5347ImmutableArray<RefKind> refKinds;
5658private SignatureOnlyMethodSymbol GetInlineArrayAccessEquivalentSignatureMethod(BoundInlineArrayAccess elementAccess, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
5660RefKind resultRefKind;
5661RefKind parameterRefKind;
5672resultRefKind = RefKind.None;
5673parameterRefKind = RefKind.None;
5677resultRefKind = elementAccess.GetItemOrSliceHelper is WellKnownMember.System_ReadOnlySpan_T__get_Item ? RefKind.In : RefKind.Ref;
5686resultRefKind = RefKind.None;
5687parameterRefKind = elementAccess.GetItemOrSliceHelper is WellKnownMember.System_ReadOnlySpan_T__Slice_Int_Int ? RefKind.In : RefKind.Ref;
5720private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundConversion conversion, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
5726private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMethod(BoundExpression inlineArray, TypeSymbol resultType, out ImmutableArray<BoundExpression> arguments, out ImmutableArray<RefKind> refKinds)
5732RefKind parameterRefKind = resultType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions) ? RefKind.In : RefKind.Ref;
5747RefKind.None,
Binder\Binder_Expressions.cs (65)
460if (field is { IsStatic: false, RefKind: RefKind.None, ContainingSymbol: SourceMemberContainerTypeSymbol { PrimaryConstructor: { } primaryConstructor } } &&
472RefKind refKind,
1995private bool IsBadLocalOrParameterCapture(Symbol symbol, TypeSymbol type, RefKind refKind)
1997if (refKind != RefKind.None || type.IsRestrictedType())
2121if (localSymbol.RefKind == RefKind.None && type.IsRestrictedType(ignoreSpanLikeTypes: true))
2169if (parameter.RefKind != RefKind.None)
2189(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) &&
2192if (parameter.RefKind != RefKind.None)
2206else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } &&
2567if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None)
3121RefKind origRefKind = argumentSyntax.RefOrOutKeyword.Kind().GetRefKind();
3125RefKind refKind = origRefKind == RefKind.None || RefMustBeObeyed(isDelegateCreation, argumentSyntax) ? origRefKind : RefKind.None;
3138if (!hadError && isDelegateCreation && origRefKind != RefKind.None && result.Arguments.Count == 1)
3145var requiredValueKind = origRefKind == RefKind.In ? BindValueKind.ReadonlyRef : BindValueKind.RefOrOut;
3157private BoundExpression BindArgumentValue(BindingDiagnosticBag diagnostics, ArgumentSyntax argumentSyntax, bool allowArglist, RefKind refKind)
3358RefKind refKind)
3366if (refKind != RefKind.None)
3376result.RefKinds.Add(RefKind.None);
3424private BoundExpression BindArgumentExpression(BindingDiagnosticBag diagnostics, ExpressionSyntax argumentExpression, RefKind refKind, bool allowArglist)
3427refKind == RefKind.None ?
3429refKind == RefKind.In ?
3797var argumentRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(handlerArgumentIndexes.Length);
3807RefKind refKind;
3813refKind = RefKind.None;
3899argumentRefKindsBuilder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind);
3922private void CheckArgumentRefKind(RefKind argRefKind, BoundExpression argument, int arg, ParameterSymbol parameter,
3934if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter)
3946if (argRefKind == RefKind.Ref)
3948if (parameter.RefKind == RefKind.In)
3958else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter)
5064if (analyzedArguments.RefKind(i) is (RefKind.Ref or RefKind.Out))
5586ArrayBuilder<RefKind> refKinds,
5779var rhsExpr = initializer.Right.CheckAndUnwrapRefExpression(diagnostics, out RefKind refKind);
5780bool isRef = refKind == RefKind.Ref;
5953ImmutableArray<RefKind> argumentRefKindsOpt = default;
8408extensionMethodArguments.RefKinds.Add(RefKind.None);
8558RefKind returnRefKind,
8640RefKind returnRefKind,
8747RefKind returnRefKind,
8978fieldSymbol.RefKind != RefKind.None)
9940RefKind refKind = analyzedArguments.RefKind(i);
9941if (refKind != RefKind.None)
10040default(ImmutableArray<RefKind>),
10158ImmutableArray<RefKind> argumentRefKinds = analyzedArguments.RefKinds.ToImmutableOrNull();
10409original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None })
10510original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } &&
10511original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None };
10574getMethod.RefKind == RefKind.None &&
10618RefKind returnRefKind = default,
10642RefKind returnRefKind = default,
10674RefKind returnRefKind = default,
10745RefKind returnRefKind = default,
11209RefKind? returnRefKindOverride = null,
11216var returnRefKind = returnRefKindOverride ?? methodSymbol.RefKind;
11234if (returnsVoid && returnRefKind != RefKind.None)
11248returnRefKind == RefKind.None &&
11250(parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)) &&
11284parameterRefKinds.IsDefault ? RefKind.None : parameterRefKinds[i],
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)
863internal BoundExpression BindInferredVariableInitializer(BindingDiagnosticBag diagnostics, RefKind refKind, EqualsValueClauseSyntax initializer,
912RefKind variableRefKind,
917RefKind expressionRefKind = RefKind.None;
919if (variableRefKind == RefKind.None)
922if (expressionRefKind == RefKind.Ref)
930valueKind = variableRefKind == RefKind.RefReadOnly
939else if (expressionRefKind != RefKind.Ref)
1000if (localSymbol.RefKind != RefKind.None)
1066localSymbol.RefKind != RefKind.None ? ConversionForAssignmentFlags.RefAssignment : ConversionForAssignmentFlags.None);
1415var rhsExpr = node.Right.CheckAndUnwrapRefExpression(diagnostics, out var refKind);
1416var isRef = refKind == RefKind.Ref;
1445var lhsRefKind = boundLeft.GetRefKind();
1446if (lhsRefKind is RefKind.Ref or RefKind.Out)
2178var delegateRefKind = delegateParameters[i].RefKind;
2179var lambdaRefKind = anonymousFunction.RefKind(i);
2187if (delegateRefKind == RefKind.None)
2236var lambdaRefKind = anonymousFunction.RefKind(i);
2238var delegateRefKind = delegateParameters[i].RefKind;
3003protected virtual TypeSymbol GetCurrentReturnType(out RefKind refKind)
3020refKind = RefKind.None;
3026var refKind = RefKind.None;
3044RefKind sigRefKind;
3055if (refKind != RefKind.None)
3067else if ((object)retType != null && (refKind != RefKind.None) != (sigRefKind != RefKind.None))
3069var errorCode = refKind != RefKind.None
3167RefKind returnRefKind,
3177Debug.Assert(returnRefKind == RefKind.None);
3199if (returnRefKind != RefKind.None)
3215RefKind unusedRefKind;
3485internal BoundBlock CreateBlockFromExpression(CSharpSyntaxNode node, ImmutableArray<LocalSymbol> locals, RefKind refKind, BoundExpression expression, ExpressionSyntax expressionSyntax, BindingDiagnosticBag diagnostics)
3487RefKind returnRefKind;
3492if (IsInAsyncMethod() && refKind != RefKind.None)
3501if ((refKind != RefKind.None) != (returnRefKind != RefKind.None) && expression.Kind != BoundKind.ThrowExpression)
3503var errorCode = refKind != RefKind.None
3508statement = new BoundReturnStatement(syntax, RefKind.None, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true };
3612RefKind refKind;
3628RefKind refKind;
3641return bodyBinder.CreateBlockFromExpression(body, bodyBinder.GetDeclaredLocalsForScope(body), RefKind.None, expression, body, diagnostics);
3644private BindValueKind GetRequiredReturnValueKind(RefKind refKind)
3647if (refKind != RefKind.None)
3649GetCurrentReturnType(out var sigRefKind);
3650requiredValueKind = sigRefKind == RefKind.Ref ?
4001argumentRefKindsOpt: ImmutableArray<RefKind>.Empty,
Binder\Semantics\OverloadResolution\OverloadResolution.cs (83)
145RefKind returnRefKind = default,
193RefKind returnRefKind = default,
434RefKind returnRefKind,
850RefKind? returnRefKind,
875else if (returnRefKind == RefKind.None)
2177var type1 = getParameterTypeAndRefKind(i, m1.Result, m1LeastOverriddenParameters, m1.Result.ParamsElementTypeOpt, m1.LeastOverriddenMember, out RefKind parameter1RefKind);
2179var type2 = getParameterTypeAndRefKind(i, m2.Result, m2LeastOverriddenParameters, m2.Result.ParamsElementTypeOpt, m2.LeastOverriddenMember, out RefKind parameter2RefKind);
2569TypeWithAnnotations paramsElementTypeOpt, TMember member, out RefKind parameterRefKind)
2634RefKind refKind1 = GetParameterBetternessRefKind(p1, m1.Member);
2635RefKind refKind2 = GetParameterBetternessRefKind(p2, m2.Member);
2637if (refKind1 == RefKind.None && isAcceptableRefMismatch(refKind2, isInterpolatedStringHandlerConversion))
2648else if (refKind2 == RefKind.None && isAcceptableRefMismatch(refKind1, isInterpolatedStringHandlerConversion))
2665static bool isAcceptableRefMismatch(RefKind refKind, bool isInterpolatedStringHandlerConversion)
2669RefKind.In or RefKind.RefReadOnlyParameter => true,
2670RefKind.Ref when isInterpolatedStringHandlerConversion => true,
2676private static RefKind GetParameterBetternessRefKind<TMember>(ParameterSymbol parameter, TMember member) where TMember : Symbol
2683return isExtensionParameterOfStaticExtensionMember ? RefKind.None : parameter.RefKind;
2881RefKind refKind1,
2884RefKind refKind2,
2909Debug.Assert(refKind1 == RefKind.None || refKind1 == RefKind.Ref);
2910Debug.Assert(refKind2 == RefKind.None || refKind2 == RefKind.Ref);
2914if (refKind1 == RefKind.None)
2923else if (refKind1 == RefKind.Ref)
3847ArrayBuilder<RefKind> argumentRefKinds,
3853out ImmutableArray<RefKind> parameterRefKinds)
3869internal readonly ImmutableArray<RefKind> ParameterRefKinds;
3872internal EffectiveParameters(ImmutableArray<TypeWithAnnotations> types, ImmutableArray<RefKind> refKinds, int firstParamsElementIndex)
3886ArrayBuilder<RefKind> argumentRefKinds,
3907hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None;
3918ArrayBuilder<RefKind> refs = null;
3932RefKind argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None;
3933RefKind paramRefKind = GetEffectiveParameterRefKind(parameter, argRefKind, options, binder, ref hasAnyRefOmittedArgument);
3937if (paramRefKind != RefKind.None)
3939refs = ArrayBuilder<RefKind>.GetInstance(arg, RefKind.None);
3949var refKinds = refs != null ? refs.ToImmutableAndFree() : default(ImmutableArray<RefKind>);
3953private static RefKind GetEffectiveParameterRefKind(
3955RefKind argRefKind,
3960var paramRefKind = parameter.RefKind;
3969if (paramRefKind == RefKind.In)
3971if (argRefKind == RefKind.None)
3973return RefKind.None;
3976if (argRefKind == RefKind.Ref && binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureRefReadonlyParameters))
3978return RefKind.Ref;
3981else if (paramRefKind == RefKind.RefReadOnlyParameter && argRefKind is RefKind.None or RefKind.Ref or RefKind.In)
3994if ((options & Options.AllowRefOmittedArguments) != 0 && paramRefKind == RefKind.Ref && argRefKind == RefKind.None && !binder.InAttributeArgument)
3997return RefKind.None;
4006internal static bool AreRefsCompatibleForMethodConversion(RefKind candidateMethodParameterRefKind, RefKind delegateParameterRefKind, CSharpCompilation compilation)
4016(RefKind.RefReadOnlyParameter, RefKind.Ref) or
4017(RefKind.RefReadOnlyParameter, RefKind.In) or
4018(RefKind.In, RefKind.RefReadOnlyParameter))
4024(candidateMethodParameterRefKind, delegateParameterRefKind) is (RefKind.In, RefKind.Ref))
4036ArrayBuilder<RefKind> argumentRefKinds,
4047ArrayBuilder<RefKind> argumentRefKinds,
4055var refs = ArrayBuilder<RefKind>.GetInstance();
4085var argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None;
4086var paramRefKind = GetEffectiveParameterRefKind(parameter, argRefKind, options, binder, ref hasAnyRefOmittedArgument);
4089if (paramRefKind != RefKind.None)
4095var refKinds = anyRef ? refs.ToImmutable() : default(ImmutableArray<RefKind>);
4567RefKind argumentRefKind = arguments.RefKind(argumentPosition);
4568RefKind parameterRefKind = parameters.ParameterRefKinds.IsDefault ? RefKind.None : parameters.ParameterRefKinds[argumentPosition];
4573if (argumentRefKind == RefKind.None)
4575if (parameterRefKind == RefKind.Ref)
4594&& parameterRefKind == RefKind.Ref
4690RefKind argRefKind,
4692RefKind parRefKind,
4729Debug.Assert(argRefKind != RefKind.None);
4735if (argRefKind == RefKind.None || hasInterpolatedStringRefMismatch)
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\Constructors.cs (28)
63fieldSymbol.RefKind != RefKind.None ||
93ImmutableArray<RefKind> argumentRefKindsOpt,
111ImmutableArray<RefKind> argumentRefKindsOpt,
127ImmutableArray<RefKind> refKinds,
190public static BoundCall Synthesized(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt = default)
199var parameterRefKind = method.ParameterRefKinds.IsDefault ? RefKind.None : method.ParameterRefKinds[i];
200var argumentRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i];
201Debug.Assert(argumentRefKind is RefKind.None or RefKind.Ref or RefKind.In or RefKind.Out or RefKindExtensions.StrictIn &&
205RefKind.In => argumentRefKind == RefKindExtensions.StrictIn,
206RefKind.RefReadOnlyParameter => argumentRefKind is RefKind.In or RefKindExtensions.StrictIn,
237static ImmutableArray<RefKind> getArgumentRefKinds(MethodSymbol method)
241if (!result.IsDefaultOrEmpty && result.Contains(RefKind.RefReadOnlyParameter))
243var builder = ArrayBuilder<RefKind>.GetInstance(result.Length);
245foreach (var refKind in result)
247builder.Add(refKind == RefKind.RefReadOnlyParameter ? RefKind.In : refKind);
261: this(syntax, constructor, ImmutableArray.Create<BoundExpression>(arguments), default(ImmutableArray<string?>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), default(BitVector), null, null, constructor.ContainingType)
265: this(syntax, constructor, arguments, default(ImmutableArray<string?>), default(ImmutableArray<RefKind>), false, default(ImmutableArray<int>), default(BitVector), null, null, constructor.ContainingType)
278ImmutableArray<RefKind> refKinds,
304ImmutableArray<RefKind> argumentRefKindsOpt,
319ImmutableArray<RefKind> argumentRefKindsOpt,
567public static BoundReturnStatement Synthesized(SyntaxNode syntax, RefKind refKind, BoundExpression expression, bool hasErrors = false)
BoundTree\UnboundLambda.cs (49)
43internal readonly RefKind RefKind;
53RefKind refKind,
178ImmutableArray<RefKind> parameterRefKinds,
179RefKind refKind)
184parameterRefKinds.IsDefault ? Enumerable.Repeat(RefKind.None, parameterTypes.Length).ToImmutableArray() : parameterRefKinds,
214RefKind refKind = RefKind.None;
217RefKind rk = returnStatement.RefKind;
218if (rk != RefKind.None)
402RefKind returnRefKind,
405ImmutableArray<RefKind> refKinds,
471public bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
496public RefKind RefKind(int index) { return Data.RefKind(index); }
586public abstract bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType);
593public abstract RefKind RefKind(int index);
668private static TypeWithAnnotations DelegateReturnTypeWithAnnotations(MethodSymbol? invokeMethod, out RefKind refKind)
672refKind = CodeAnalysis.RefKind.None;
679internal (ImmutableArray<RefKind>, ArrayBuilder<ScopedKind>, ImmutableArray<TypeWithAnnotations>, bool) CollectParameterProperties()
681var parameterRefKindsBuilder = ArrayBuilder<RefKind>.GetInstance(ParameterCount);
688var refKind = RefKind(i);
745if (!HasExplicitReturnType(out var returnRefKind, out var returnType))
809var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind);
828refKind == CodeAnalysis.RefKind.None &&
848if (lambdaSymbol.RefKind == CodeAnalysis.RefKind.RefReadOnly)
915ImmutableArray<RefKind> parameterRefKinds,
916RefKind refKind)
930var returnType = DelegateReturnTypeWithAnnotations(invokeMethod, out RefKind refKind);
963ImmutableArray<RefKind> parameterRefKinds)
965bool hasExplicitReturnType = HasExplicitReturnType(out var refKind, out var returnType);
1020ImmutableArray<RefKind> parameterRefKinds,
1022RefKind refKind)
1056public readonly ImmutableArray<RefKind> ParameterRefKinds;
1059public static readonly ReturnInferenceCacheKey Empty = new ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty, null);
1061private ReturnInferenceCacheKey(ImmutableArray<TypeWithAnnotations> parameterTypes, ImmutableArray<RefKind> parameterRefKinds, NamedTypeSymbol? taskLikeReturnTypeOpt)
1122out ImmutableArray<RefKind> parameterRefKinds,
1128parameterRefKinds = ImmutableArray<RefKind>.Empty;
1137var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameterCount);
1213?? rebind(ReallyInferReturnType(delegateType: null, ImmutableArray<TypeWithAnnotations>.Empty, ImmutableArray<RefKind>.Empty));
1230ImmutableArray<RefKind> parameterRefKinds)
1233var refKind = inferredReturnType.RefKind;
1245refKind = CodeAnalysis.RefKind.None;
1458private readonly RefKind _returnRefKind;
1464private readonly ImmutableArray<RefKind> _parameterRefKinds;
1473RefKind returnRefKind,
1479ImmutableArray<RefKind> parameterRefKinds,
1504public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnnotations returnType)
1564public override RefKind RefKind(int index)
1567return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index];
1601statements[0] is BoundReturnStatement { RefKind: Microsoft.CodeAnalysis.RefKind.None, ExpressionOpt: BoundExpression expr })
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\EmitExpression.cs (59)
710RefKind refKind = expression.ArgumentRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : expression.ArgumentRefKindsOpt[i];
715private void EmitArgument(BoundExpression argument, RefKind refKind)
719case RefKind.None:
724Debug.Assert(refKind is RefKind.In or RefKind.Ref or RefKind.Out or RefKindExtensions.StrictIn);
730Debug.Assert(refKind is RefKind.In || argument.Type.IsDynamic() || argument is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None }, "passing args byref should not clone them into temps");
738internal static AddressKind GetArgumentAddressKind(RefKind refKind)
742case RefKind.None:
745case RefKind.In:
749Debug.Assert(refKind is RefKind.Ref or RefKind.Out or RefKindExtensions.StrictIn);
790if (expression.RefKind == RefKind.None)
957private void EmitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt)
962Debug.Assert(parameters.All(p => p.RefKind == RefKind.None) || !argRefKindsOpt.IsDefault, "there are nontrivial parameters, so we must have argRefKinds");
969RefKind argRefKind = GetArgumentRefKind(arguments, parameters, argRefKindsOpt, i);
978internal static RefKind GetArgumentRefKind(ImmutableArray<BoundExpression> arguments, ImmutableArray<ParameterSymbol> parameters, ImmutableArray<RefKind> argRefKindsOpt, int i)
980RefKind argRefKind;
991RefKind.In => argRefKind == RefKindExtensions.StrictIn,
992RefKind.RefReadOnlyParameter => argRefKind is RefKind.In or RefKindExtensions.StrictIn,
999Debug.Assert(parameters[i].RefKind != RefKind.RefReadOnlyParameter,
1005RefKind.RefReadOnlyParameter => RefKind.In, // should not happen, asserted above
1014argRefKind = RefKind.None;
1143if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None)
1155if (field.RefKind != RefKind.None)
1299return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None;
1303return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None;
1312if (field.IsStatic || field.RefKind != RefKind.None)
1403bool isRefLocal = local.LocalSymbol.RefKind != RefKind.None;
1435if (parameter.ParameterSymbol.RefKind != RefKind.None)
1758var methodRefKind = call.Method.RefKind;
2241return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None;
2244return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None;
2247return ((BoundCall)receiver).Method.RefKind != RefKind.None;
2250return ((BoundFunctionPointerInvocation)receiver).FunctionPointer.Signature.RefKind != RefKind.None;
2253return ((BoundDup)receiver).RefKind != RefKind.None;
2665if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) &&
2796return ((BoundParameter)left).ParameterSymbol.RefKind == RefKind.None;
2801return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None;
2821if (left.FieldSymbol.RefKind != RefKind.None &&
2839if (left.ParameterSymbol.RefKind != RefKind.None &&
2871if (left.LocalSymbol.RefKind != RefKind.None && !assignmentOperator.IsRef)
2970Debug.Assert(left.Method.RefKind != RefKind.None);
2981Debug.Assert(left.FunctionPointer.Signature.RefKind != RefKind.None);
3033LocalDefinition temp = EmitAddress(assignmentOperator.Right, lhs.GetRefKind() is RefKind.RefReadOnly or RefKindExtensions.StrictIn or RefKind.RefReadOnlyParameter ? AddressKind.ReadOnlyStrict : AddressKind.Writeable);
3116if (local.LocalSymbol.RefKind != RefKind.None && !assignment.IsRef)
3149Debug.Assert(((BoundDup)expression).RefKind != RefKind.None);
3172Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None);
3177Debug.Assert(((BoundFunctionPointerInvocation)expression).FunctionPointer.Signature.RefKind != RefKind.None);
3321if (field.RefKind != RefKind.None && !refAssign)
3336if (parameter.ParameterSymbol.RefKind != RefKind.None && !refAssign)
4133if (useKind == UseKind.UsedAsValue && method.RefKind != RefKind.None)
4139Debug.Assert(method.RefKind != RefKind.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; }
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,
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\DefiniteAssignment.cs (21)
350NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None);
811write: field.RefKind == RefKind.None || isRef);
923write: field.RefKind == RefKind.None || isRef);
1186((ParameterSymbol)symbol).RefKind == RefKind.Out)
1286if (fieldSymbol.RefKind != RefKind.None)
1470if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess)
1523if (local.LocalSymbol.RefKind != RefKind.None && !isRef)
1574if (isRef && param.RefKind == RefKind.Out)
1592write: field.RefKind == RefKind.None || isRef);
1766if (parameter.RefKind != RefKind.Out)
1778if (thisParameter.RefKind != RefKind.Out)
1790if (extensionParameter.RefKind != RefKind.Out)
1813if (current is not MethodSymbol && parameter.RefKind == RefKind.Out)
1843if (parameter.RefKind == RefKind.Out && !(this.CurrentSymbol is MethodSymbol currentMethod && currentMethod.IsAsync)) // out parameters not allowed in async
1851NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None);
1909if (!parameter.IsThis && parameter.RefKind != RefKind.Out && parameter.ContainingSymbol is SynthesizedPrimaryConstructor primaryCtor)
1921if (parameter.RefKind != RefKind.None)
2523protected override void WriteArgument(BoundExpression arg, RefKind refKind, MethodSymbol method)
2525if (refKind == RefKind.Ref)
2539if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type)
2729NoteWrite(iterationVariable, null, read: true, isRef: iterationVariable.RefKind != RefKind.None);
FlowAnalysis\NullableWalker.cs (66)
1365var refKind = parameter.RefKind;
1366if (refKind != RefKind.Out && refKind != RefKind.Ref)
2492RefKind refKind,
2502if (refKind == RefKind.Ref)
2505return AreParameterAnnotationsCompatible(RefKind.None, overriddenType, overriddenAnnotations, overridingType, overridingAnnotations, forRef: true) &&
2506AreParameterAnnotationsCompatible(RefKind.Out, overriddenType, overriddenAnnotations, overridingType, overridingAnnotations);
2509if (refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)
2539if (refKind == RefKind.Out)
3003if (parameter.RefKind != RefKind.Out)
3076if (node.RefKind == RefKind.None &&
3085if (node.RefKind == RefKind.None)
6576var refKind = isNewExtensionMethod ? GetExtensionReceiverRefKind(node.Method) : GetRefKind(node.ArgumentRefKindsOpt, 0);
6707ImmutableArray<RefKind> refKindsOpt,
6763internal static ImmutableArray<RefKind> GetArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, bool adjustForNewExtension,
6772RefKind receiverRefKind = GetExtensionReceiverRefKind(method);
6776if (receiverRefKind == RefKind.None)
6781var builder = ArrayBuilder<RefKind>.GetInstance(argumentCount + 1, fillWithValue: RefKind.None);
6789private static RefKind GetExtensionReceiverRefKind(MethodSymbol method)
6796return extensionParameter.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.None;
7229protected override void VisitArguments(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> refKindsOpt, MethodSymbol method, ImmutableArray<int> argsToParamsOpt, bool expanded)
7238ImmutableArray<RefKind> refKindsOpt,
7251ImmutableArray<RefKind> refKindsOpt,
7264ImmutableArray<RefKind> refKindsOpt,
7286ImmutableArray<RefKind> refKindsOpt,
7328ImmutableArray<RefKind> refKindsOpt,
7517ImmutableArray<RefKind> refKindsOpt,
7535static void expandParamsCollection(ref ImmutableArray<BoundExpression> arguments, ref ImmutableArray<RefKind> refKindsOpt, ImmutableArray<ParameterSymbol> parametersOpt, ref ImmutableArray<int> argsToParamsOpt, ref BitVector defaultArguments)
7595var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(refKindsOpt.Length + elements.Length - 1);
7597refKindsBuilder.AddMany(RefKind.None, elements.Length);
7770ImmutableArray<RefKind> refKindsOpt,
7831private VisitResult VisitArgumentEvaluate(BoundExpression argument, RefKind refKind, FlowAnalysisAnnotations annotations)
7843private VisitResult VisitArgumentEvaluateEpilogue(BoundExpression argument, RefKind refKind, FlowAnalysisAnnotations annotations)
7849case RefKind.Ref:
7852case RefKind.None:
7853case RefKind.In:
7875case RefKind.Out:
7898RefKind refKind,
7913case RefKind.None:
7914case RefKind.In:
7952case RefKind.Ref:
7972case RefKind.Out:
8035RefKind refKind,
8048case RefKind.None:
8049case RefKind.In:
8055case RefKind.Ref:
8082case RefKind.Out:
8288ImmutableArray<RefKind> refKindsOpt)
8299RefKind refKind = GetRefKind(refKindsOpt, i);
8302if (refKind == RefKind.None)
8370ImmutableArray<RefKind> argumentRefKindsOpt,
8380var refKinds = ArrayBuilder<RefKind>.GetInstance();
8401parameterRefKinds: out ImmutableArray<RefKind> parameterRefKinds);
10759case BoundLocal { LocalSymbol.RefKind: RefKind.None }:
10760case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameter } when
11481ImmutableArray<RefKind> refKindsOpt = extensionParameter.RefKind == RefKind.Ref ? [RefKind.Ref] : default;
12954TypeWithAnnotations elementType = InMethodBinder.GetIteratorElementTypeFromReturnType(compilation, RefKind.None,
12994VisitArguments(node, node.ConstructorArguments, ImmutableArray<RefKind>.Empty, node.Constructor, argsToParamsOpt: node.ConstructorArgumentsToParamsOpt, defaultArguments: node.ConstructorDefaultArguments,
Generated\BoundNodes.xml.Generated.cs (37)
902public BoundDup(SyntaxNode syntax, RefKind refKind, TypeSymbol? type, bool hasErrors)
908public BoundDup(SyntaxNode syntax, RefKind refKind, TypeSymbol? type)
914public RefKind RefKind { get; }
919public BoundDup Update(RefKind refKind, TypeSymbol? type)
1427public BoundFunctionPointerInvocation(SyntaxNode syntax, BoundExpression invokedExpression, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt, LookupResultKind resultKind, TypeSymbol type, bool hasErrors = false)
1444public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
1450public BoundFunctionPointerInvocation Update(BoundExpression invokedExpression, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt, LookupResultKind resultKind, TypeSymbol type)
3063public BoundArgListOperator(SyntaxNode syntax, ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt, TypeSymbol? type, bool hasErrors = false)
3075public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
3080public BoundArgListOperator Update(ImmutableArray<BoundExpression> arguments, ImmutableArray<RefKind> argumentRefKindsOpt, TypeSymbol? type)
3569public BoundReturnStatement(SyntaxNode syntax, RefKind refKind, BoundExpression? expressionOpt, bool @checked, bool hasErrors = false)
3577public RefKind RefKind { get; }
3584public BoundReturnStatement Update(RefKind refKind, BoundExpression? expressionOpt, bool @checked)
5891public BoundDynamicInvocation(SyntaxNode syntax, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<MethodSymbol> applicableMethods, BoundExpression expression, ImmutableArray<BoundExpression> arguments, TypeSymbol type, bool hasErrors = false)
5907public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
5913public BoundDynamicInvocation Update(ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<MethodSymbol> applicableMethods, BoundExpression expression, ImmutableArray<BoundExpression> arguments, TypeSymbol type)
6141public BoundCall(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalMethodsOpt, TypeSymbol type, bool hasErrors = false)
6174public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
6186public BoundCall Update(BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, MethodSymbol method, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool isDelegateCall, bool expanded, bool invokedAsExtensionMethod, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, LookupResultKind resultKind, ImmutableArray<MethodSymbol> originalMethodsOpt, TypeSymbol type)
6284public BoundUnconvertedObjectCreationExpression(SyntaxNode syntax, ImmutableArray<BoundExpression> arguments, ImmutableArray<(string Name, Location Location)?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, InitializerExpressionSyntax? initializerOpt, Binder binder, bool hasErrors = false)
6301public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
6308public BoundUnconvertedObjectCreationExpression Update(ImmutableArray<BoundExpression> arguments, ImmutableArray<(string Name, Location Location)?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, InitializerExpressionSyntax? initializerOpt, Binder binder)
6343public BoundObjectCreationExpression(SyntaxNode syntax, MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ConstantValue? constantValueOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
6369public override ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
6380public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableArray<MethodSymbol> constructorsGroup, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ConstantValue? constantValueOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, bool wasTargetTyped, TypeSymbol type)
6623public BoundDynamicObjectCreationExpression(SyntaxNode syntax, string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, bool wasTargetTyped, TypeSymbol type, bool hasErrors = false)
6644public override ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
6652public BoundDynamicObjectCreationExpression Update(string name, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, BoundObjectInitializerExpressionBase? initializerExpressionOpt, ImmutableArray<MethodSymbol> applicableMethods, bool wasTargetTyped, TypeSymbol type)
6745public BoundObjectInitializerMember(SyntaxNode syntax, Symbol? memberSymbol, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, LookupResultKind resultKind, AccessorKind accessorKind, TypeSymbol receiverType, TypeSymbol type, bool hasErrors = false)
6769public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
6780public BoundObjectInitializerMember Update(Symbol? memberSymbol, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, LookupResultKind resultKind, AccessorKind accessorKind, TypeSymbol receiverType, TypeSymbol type)
7413public BoundIndexerAccess(SyntaxNode syntax, BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, AccessorKind accessorKind, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ImmutableArray<PropertySymbol> originalIndexersOpt, TypeSymbol type, bool hasErrors = false)
7440public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
7450public BoundIndexerAccess Update(BoundExpression? receiverOpt, ThreeState initialBindingReceiverIsSubjectToCloning, PropertySymbol indexer, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, bool expanded, AccessorKind accessorKind, ImmutableArray<int> argsToParamsOpt, BitVector defaultArguments, ImmutableArray<PropertySymbol> originalIndexersOpt, TypeSymbol type)
7554public BoundDynamicIndexerAccess(SyntaxNode syntax, BoundExpression receiver, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<PropertySymbol> applicableIndexers, TypeSymbol type, bool hasErrors = false)
7574public ImmutableArray<RefKind> ArgumentRefKindsOpt { get; }
7580public BoundDynamicIndexerAccess Update(BoundExpression receiver, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<PropertySymbol> applicableIndexers, TypeSymbol type)
Lowering\LocalRewriter\LocalRewriter_Call.cs (88)
140ref ImmutableArray<RefKind> argumentRefKindsOpt,
300var thisRefKind = methodThisParameter.RefKind;
303if (thisRefKind != RefKind.None
306thisRefKind == RefKind.Ref ? CodeGenerator.AddressKind.Writeable : CodeGenerator.AddressKind.ReadOnlyStrict,
320if (argumentRefKindsOpt.IsDefault && thisRefKind != RefKind.None)
381ImmutableArray<RefKind> argRefKindsOpt = node.ArgumentRefKindsOpt;
461ImmutableArray<RefKind> argumentRefKinds,
548argumentRefKinds: default(ImmutableArray<RefKind>),
553private static bool IsSafeForReordering(BoundExpression expression, RefKind kind)
579return kind != RefKind.None;
667ImmutableArray<RefKind> argumentRefKindsOpt,
688RefKind refKind;
706refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None;
712refKind = RefKind.None;
718if (refKind == RefKind.None &&
725refKind = RefKind.Ref;
731receiverTemp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, refKind is RefKind.RefReadOnlyParameter ? RefKind.In : refKind);
898RefKind argRefKind = argumentRefKindsOpt.RefKinds(argIndex);
899RefKind paramRefKind = parameters[paramIndex].RefKind;
901local = _factory.StoreToTemp(visitedArgument, out var store, refKind: paramRefKind is RefKind.In or RefKind.RefReadOnlyParameter ? RefKind.In : argRefKind);
949private RefKind GetNewExtensionMemberReceiverCaptureRefKind(BoundExpression rewrittenReceiver, Symbol methodOrIndexer)
954RefKind receiverRefKind = methodOrIndexer.ContainingType.ExtensionParameter.RefKind;
955bool isReceiverTakenByValue = receiverRefKind == RefKind.None;
960return RefKind.None;
974return RefKind.None;
977RefKind refKind = ExtensionMethodReferenceRewriter.ReceiverArgumentRefKindFromReceiverRefKind(receiverRefKind);
988return RefKind.None;
1063ref ImmutableArray<RefKind> argumentRefKindsOpt,
1146ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None);
1216private static ImmutableArray<RefKind> GetEffectiveArgumentRefKinds(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters)
1218ArrayBuilder<RefKind>? refKindsBuilder = null;
1221var paramRefKind = parameters[i].RefKind;
1222var currentArgRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i];
1223var effectiveArgRefKind = GetEffectiveRefKind(paramRefKind, currentArgRefKind, parameters[i].Type, comRefKindMismatchPossible: false);
1241static void fillRefKindsBuilder(ImmutableArray<RefKind> argumentRefKindsOpt, ImmutableArray<ParameterSymbol> parameters, [NotNull] ref ArrayBuilder<RefKind>? refKindsBuilder)
1248refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameters.Length);
1253refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameters.Length, fillWithValue: RefKind.None);
1259internal static RefKind GetEffectiveRefKind(RefKind paramRefKind, RefKind initialArgRefKind, TypeSymbol paramType, bool comRefKindMismatchPossible)
1267if (paramRefKind is RefKind.In or RefKind.RefReadOnlyParameter)
1269Debug.Assert(initialArgRefKind is RefKind.None or RefKind.In or RefKind.Ref);
1270return initialArgRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn;
1272else if (paramRefKind == RefKind.Ref && initialArgRefKind == RefKind.None)
1278return RefKind.Ref;
1340private static ImmutableArray<RefKind> GetRefKindsOrNull(ArrayBuilder<RefKind> refKinds)
1342foreach (var refKind in refKinds)
1344if (refKind != RefKind.None)
1349return default(ImmutableArray<RefKind>);
1402ImmutableArray<RefKind> argumentRefKinds,
1406/* out */ ArrayBuilder<RefKind> refKinds,
1418RefKind argRefKind = argumentRefKinds.RefKinds(a);
1419RefKind paramRefKind = parameters[p].RefKind;
1427Debug.Assert(argRefKind == RefKind.None);
1443arg.rewriter.StoreArgumentToTempIfNecessary(arg.forceLambdaSpilling, arg.storesToTemps, element, RefKind.None, RefKind.None),
1459private BoundExpression StoreArgumentToTempIfNecessary(bool forceLambdaSpilling, ArrayBuilder<BoundAssignmentOperator> storesToTemps, BoundExpression argument, RefKind argRefKind, RefKind paramRefKind)
1471refKind: paramRefKind is RefKind.In or RefKind.RefReadOnlyParameter
1472? (argRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn)
1526default(ImmutableArray<RefKind>),
1686ArrayBuilder<RefKind> argsRefKindsBuilder,
1699RefKind paramRefKind = parameters[argIndex].RefKind;
1700RefKind argRefKind = argsRefKindsBuilder[argIndex];
1704if (argRefKind != RefKind.None || paramRefKind != RefKind.Ref)
1712var localRefKind = ((BoundLocal)argument).LocalSymbol.RefKind;
1713if (localRefKind == RefKind.Ref)
1719Debug.Assert(localRefKind == RefKind.None);
1731argsRefKindsBuilder[argIndex] = 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_ForEachStatement.cs (5)
610RefKind collectionTempRefKind = RefKind.None;
698private delegate BoundStatement? GetForEachStatementAsForPreamble(LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind);
737return static (LocalRewriter rewriter, SyntaxNode syntax, ForEachEnumeratorInfo enumeratorInfo, ref BoundExpression rewrittenExpression, out LocalSymbol? preambleLocal, out RefKind collectionTempRefKind) =>
751collectionTempRefKind = enumeratorInfo.InlineArraySpanType == WellKnownType.System_Span_T ? RefKind.Ref : RefKindExtensions.StrictIn;
Lowering\LocalRewriter\LocalRewriter_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\LoweredDynamicOperationFactory.cs (54)
112return MakeDynamicOperation(binderConstruction, null, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), null, resultType);
148return MakeDynamicOperation(binderConstruction, null, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), null, resultType);
191return MakeDynamicOperation(binderConstruction, null, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), null, resultType);
200ImmutableArray<RefKind> refKinds,
224RefKind receiverRefKind;
229receiverRefKind = RefKind.None;
293return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), loweredHandler, resultType);
300ImmutableArray<RefKind> refKinds,
330return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, refKinds, null, resultType);
338ImmutableArray<RefKind> refKinds)
357return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, refKinds, null, type);
392return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), null, resultType);
433return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), loweredRight, AssemblySymbol.DynamicType);
440ImmutableArray<RefKind> refKinds)
459return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, refKinds, null, resultType);
466ImmutableArray<RefKind> refKinds,
482var loweredReceiverRefKind = GetReceiverRefKind(loweredReceiver);
517return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, ImmutableArray<BoundExpression>.Empty, default(ImmutableArray<RefKind>), null, resultType);
543internal RefKind GetReceiverRefKind(BoundExpression loweredReceiver)
548return RefKind.None;
556return hasHome ? RefKind.Ref : RefKind.None;
563ImmutableArray<RefKind> refKinds = default(ImmutableArray<RefKind>),
565RefKind receiverRefKind = RefKind.None,
572Debug.Assert(!receiverIsStaticType || receiverRefKind == RefKind.None);
587refKinds.IsDefault ? RefKind.None : refKinds[i],
593infos[j++] = GetArgumentInfo(argumentInfoFactory, loweredRight, NoName, RefKind.None, isStaticType: false);
602RefKind receiverRefKind,
604ImmutableArray<RefKind> refKinds,
721RefKind receiverRefKind,
723ImmutableArray<RefKind> refKinds,
737bool hasByRefs = receiverRefKind != RefKind.None || !refKinds.IsDefaultOrEmpty;
777byRefs[j++] = RefKind.None;
792static RefKind getRefKind(RefKind refKind)
794Debug.Assert(refKind != RefKind.RefReadOnlyParameter);
795return refKind == RefKind.None ? RefKind.None : RefKind.Ref;
803RefKind refKind,
818Debug.Assert(refKind == RefKind.None || refKind == RefKind.Ref || refKind == RefKind.Out, "unexpected refKind in dynamic");
821if (refKind == RefKind.Out)
825else if (refKind == RefKind.Ref)
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\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);
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\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\Source\ParameterHelpers.cs (37)
42ParameterSyntax syntax, RefKind refKind, int ordinal,
71ParameterSyntax syntax, RefKind refKind, int ordinal,
134FunctionPointerParameterSyntax syntax, RefKind refKind, int ordinal,
144RefKind.In => CreateInModifiers(binder, diagnostics, syntax),
145RefKind.RefReadOnlyParameter => CreateRefReadonlyParameterModifiers(binder, diagnostics, syntax),
146RefKind.Out => CreateOutModifiers(binder, diagnostics, syntax),
177Func<Binder, TOwningSymbol, TypeWithAnnotations, TParameterSyntax, RefKind, int, SyntaxToken, SyntaxToken, bool, ScopedKind, BindingDiagnosticBag, TParameterSymbol> parameterCreationFunc,
257Func<Binder, TOwningSymbol, TypeWithAnnotations, TParameterSyntax, RefKind, int, SyntaxToken, SyntaxToken, bool, ScopedKind, BindingDiagnosticBag, TParameterSymbol> parameterCreationFunc,
269var refKind = GetModifiers(parameterSyntax.Modifiers, ignoreParams: inExtension, out SyntaxToken refnessKeyword, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword, out ScopedKind scope);
310if (!allowRefOrOut && (refKind == RefKind.Ref || refKind == RefKind.Out))
348if (parameter.RefKind == RefKind.In)
359else if (parameter.RefKind == RefKind.RefReadOnlyParameter)
452internal static bool IsRefScopedByDefault(bool useUpdatedEscapeRules, RefKind refKind)
454return useUpdatedEscapeRules && refKind == RefKind.Out;
839RefKind refKind,
886else if (refKind != RefKind.None &&
943var refKind = GetModifiers(parameterSyntax.Modifiers, ignoreParams: inExtension, out SyntaxToken refnessKeyword, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword, out _);
949if (refKind == RefKind.Ref || refKind == RefKind.Out)
1058if (refKind == RefKind.RefReadOnlyParameter)
1124internal static RefKind GetModifiers(SyntaxTokenList modifiers, bool ignoreParams, out SyntaxToken refnessKeyword, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword, out ScopedKind scope)
1126var refKind = RefKind.None;
1138if (refKind == RefKind.None)
1141refKind = RefKind.Out;
1145if (refKind == RefKind.None)
1148refKind = RefKind.Ref;
1152if (refKind == RefKind.None)
1155refKind = RefKind.In;
1168Debug.Assert(refKind == RefKind.None);
1172if (refKind == RefKind.Ref && refnessKeyword.GetNextToken() == modifier)
1174refKind = RefKind.RefReadOnlyParameter;
1182scope = (refKind == RefKind.None) ? ScopedKind.ScopedValue : ScopedKind.ScopedRef;
1192internal static ImmutableArray<CustomModifier> ConditionallyCreateInModifiers(RefKind refKind, bool addRefReadOnlyModifier, Binder binder, BindingDiagnosticBag diagnostics, SyntaxNode syntax)
1194if (addRefReadOnlyModifier && refKind is RefKind.In or RefKind.RefReadOnlyParameter)
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\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\Synthesized\Records\SynthesizedPrimaryConstructor.cs (1)
44RefKind.None,
Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (1)
41RefKind.Out,
Symbols\Synthesized\Records\SynthesizedRecordEqualityContractProperty.cs (1)
42RefKind.None,
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\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\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,
InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)
250RefKind.None,
InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (1)
342RefKind.None,
src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
544case RefKind.Out:
551case RefKind.Ref:
src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)
76refKind: RefKind.None,
src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)
254refKind: RefKind.None,
src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (8)
144document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None));
158document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None));
172document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None));
220parameter.RefKind is RefKind.Out ||
245private static RefKind GetRefKindFromContext(State state)
249return RefKind.Ref;
253return RefKind.RefReadOnly;
257return RefKind.None;
src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateParameterCodeAction.cs (1)
49RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
AbstractDoNotCopyValue.cs (70)
400var parameterRefKind = operation.Parameter.RefKind;
401var sourceRefKind = Acquire(operation.Value);
503if (!operation.IsRef && Acquire(operation) != RefKind.None)
576case RefKind.None:
577case RefKind.Ref or RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter when operation.Conversion.IsIdentity:
865&& Acquire(instance) is RefKind.In or RefKindEx.RefReadOnlyParameter)
1024if (Acquire(operation) != RefKind.None)
1032&& Acquire(instance) is RefKind.In or RefKindEx.RefReadOnlyParameter)
1098if (returnedValue is not null && Acquire(returnedValue) != RefKind.None)
1104else if (returnedValue is IParameterReferenceOperation { Parameter.RefKind: RefKind.None })
1108else if (operation.GetRefKind(_context.OwningSymbol) == RefKind.None && Cache.IsNonCopyableType(returnedValue.Type))
1125var sourceRefKind = Acquire(value);
1129&& sourceRefKind != RefKind.None)
1266if (Acquire(resource) != RefKind.None)
1284var localRefKind = symbol.RefKind;
1285var sourceRefKind = Acquire(operation.Initializer?.Value);
1310var localRefKind = operation.Symbol.RefKind;
1311var sourceRefKind = Acquire(operation.Initializer?.Value);
1351private static bool CanAssign(RefKind sourceRefKind, RefKind targetRefKind)
1355(RefKind.None, _) => true,
1356(RefKind.Ref, RefKind.Ref or RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter) => true,
1357(RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter, RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter) => true,
1362protected RefKind Acquire(IOperation? operation)
1365return RefKind.RefReadOnly;
1370return RefKind.Ref;
1377=> RefKind.None,
1390{ ReturnsByRefReadonly: true } => RefKind.RefReadOnly,
1391{ ReturnsByRef: true } => RefKind.Ref,
1392_ => RefKind.None,
1396return RefKind.None;
1400return field.IsReadOnly ? RefKind.RefReadOnly : RefKind.Ref;
1403return _context.OwningSymbol.IsReadOnly() ? RefKind.RefReadOnly : RefKind.Ref;
1408{ ReturnsByRefReadonly: true } => RefKind.RefReadOnly,
1409{ ReturnsByRef: true } => RefKind.Ref,
1410_ => RefKind.None,
1414return RefKind.None;
1418return local.RefKind == RefKind.RefReadOnly ? RefKind.RefReadOnly : RefKind.Ref;
1421return RefKind.None;
1425return parameter.RefKind is RefKind.In or RefKindEx.RefReadOnlyParameter ? parameter.RefKind : RefKind.Ref;
1434{ ReturnsByRefReadonly: true } => RefKind.RefReadOnly,
1435{ ReturnsByRef: true } => RefKind.Ref,
1436_ => RefKind.None,
1440return RefKind.None;
1443return RefKind.None;
1446return RefKind.RefReadOnly;
1450static RefKind CombineRestrictions(RefKind first, RefKind second)
1454(RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter, _) => RefKind.RefReadOnly,
1455(_, RefKind.RefReadOnly or RefKindEx.RefReadOnlyParameter) => RefKind.RefReadOnly,
1456(RefKind.Out, _) => RefKind.Out,
1457(_, RefKind.Out) => RefKind.Out,
1458(RefKind.None, RefKind.None) => RefKind.None,
1459_ => RefKind.Ref,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (10)
48RefKind refKind,
79ITypeSymbol type, RefKind refKind, ImmutableArray<IPropertySymbol> explicitInterfaceImplementations, string name,
153RefKind refKind,
175RefKind refKind,
265=> CreateParameterSymbol(RefKind.None, type, name);
267public static IParameterSymbol CreateParameterSymbol(RefKind refKind, ITypeSymbol type, string name)
277ImmutableArray<AttributeData> attributes, RefKind refKind, bool isParams, ITypeSymbol type, string name, bool isOptional = false, bool hasDefaultValue = false, object? defaultValue = null)
288RefKind? refKind = null,
392refKind: RefKind.None,
464RefKind refKind,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
51refKind: RefKind.None,