1019 references to None
ConfigurationSchemaGenerator (1)
RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (1)
704else if (parameter.RefKind is not RefKind.None)
GenerateDocumentationAndConfigFiles (18)
src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
185Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (2)
265=> CreateParameterSymbol(RefKind.None, type, name); 392refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (1)
79public RefKind RefKind => RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
ILLink.RoslynAnalyzer (8)
DataFlow\LocalDataFlowVisitor.cs (1)
296if (propertyRef.Property.RefKind is not RefKind.None)
DynamicallyAccessedMembersAnalyzer.cs (3)
184if (member is IFieldSymbol field && field.GetDynamicallyAccessedMemberTypes() != DynamicallyAccessedMemberTypes.None && !field.Type.IsTypeInterestingForDataflow(isByRef: field.RefKind is not RefKind.None)) 194if (parameter.GetDynamicallyAccessedMemberTypes() != DynamicallyAccessedMemberTypes.None && !parameter.Type.IsTypeInterestingForDataflow(isByRef: parameter.RefKind is not RefKind.None)) 331|| !propertySymbol.Type.IsTypeInterestingForDataflow(isByRef: propertySymbol.RefKind is not RefKind.None)
IOperationExtensions.cs (1)
210return containingMethod?.RefKind ?? RefKind.None;
TrimAnalysis\FlowAnnotations.cs (2)
117if (!field.OriginalDefinition.Type.IsTypeInterestingForDataflow(isByRef: field.RefKind is not RefKind.None)) 169bool isByRef = parameter.RefKind is not RefKind.None;
TrimAnalysis\ParameterProxy.cs (1)
32case RefKind.None: return ReferenceKind.None;
Microsoft.CodeAnalysis (7)
DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)
796if ((symbol.RefKind == RefKind.None) == parameterInfo.IsRefOrOut)
DocumentationCommentId.cs (2)
501if (p.RefKind != RefKind.None) 1459if ((symbol.RefKind == RefKind.None) == parameterInfo.IsRefOrOut)
Operations\ControlFlowGraphBuilder.cs (1)
4665return new SimpleAssignmentOperation(isRef: local.RefKind != RefKind.None,
Operations\OperationExtensions.cs (1)
322return RefKind.None;
Symbols\ISymbolExtensions.cs (1)
146if (enterScopeMethod is not { ReturnsVoid: false, RefKind: RefKind.None })
Symbols\RefKind.cs (1)
83case RefKind.None: return string.Empty;
Microsoft.CodeAnalysis.Analyzers (18)
src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
185Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (2)
265=> CreateParameterSymbol(RefKind.None, type, name); 392refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (1)
79public RefKind RefKind => RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
Microsoft.CodeAnalysis.AnalyzerUtilities (13)
src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
185Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (1)
182Debug.Assert(parameter.RefKind != RefKind.None);
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (1)
758&& (a.Parameter.RefKind == RefKind.None
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AbstractLocationDataFlowOperationVisitor.cs (1)
44if (parameter.RefKind == RefKind.None)
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AddressSharedEntitiesProvider.cs (1)
46if (parameter.RefKind != RefKind.None &&
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityDataFlowOperationVisitor.cs (1)
308if (parameter.RefKind != RefKind.None)
src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (1)
596if (parameter.RefKind == RefKind.None || DataFlowAnalysisContext.InterproceduralAnalysisData == null)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
Microsoft.CodeAnalysis.CodeStyle (15)
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)
965methodSymbol.Parameters[0].RefKind == RefKind.None &&
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
606if (symbol is IParameterSymbol { RefKind: not RefKind.None } || 607symbol is ILocalSymbol { RefKind: not RefKind.None } ||
src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)
134RefKind: RefKind.None, 367if (property.RefKind != RefKind.None)
src\roslyn\src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)
120if (isTopLevel && symbol is IPropertySymbol { RefKind: RefKind.None })
src\roslyn\src\Analyzers\Core\Analyzers\UseConditionalExpression\ForReturn\UseConditionalExpressionForReturnHelpers.cs (2)
89syntaxFacts, anyReturn.GetRefKind(containingSymbol) != RefKind.None, 130isRef = anyReturn.GetRefKind(containingSymbol) != RefKind.None;
src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)
796if ((symbol.RefKind == RefKind.None) == parameterInfo.IsRefOrOut)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
Microsoft.CodeAnalysis.CodeStyle.Fixes (21)
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)
76refKind: RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)
254refKind: RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.CodeAction.cs (2)
63var setAccessor = _isReadonly || _refKind != RefKind.None 118return _state.TypeToGenerateIn.TypeKind != TypeKind.Interface && _refKind != RefKind.None
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)
147document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None)); 161document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None)); 175document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None)); 260return RefKind.None;
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateParameterCodeAction.cs (1)
49RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (1)
198g.Argument(DisposingName, RefKind.None, g.TrueLiteralExpression())))));
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (2)
265=> CreateParameterSymbol(RefKind.None, type, name); 392refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (1)
79public RefKind RefKind => RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
Microsoft.CodeAnalysis.CSharp (737)
Binder\Binder.QueryUnboundLambdaState.cs (1)
50public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }
Binder\Binder.ValueChecks.cs (67)
53Method is { RefKind: not RefKind.None, ReturnType: { } returnType } && 615if (indexerAccess.Indexer.RefKind != RefKind.None) 1335(localSymbol.RefKind == RefKind.None && !localSymbol.IsWritableVariable)) 1343if (localSymbol.RefKind == RefKind.None) 1375if (localSymbol.RefKind == RefKind.None) 1421else if (parameterSymbol.RefKind == RefKind.None && RequiresRefAssignableVariable(valueKind)) 1427Debug.Assert(parameterSymbol.RefKind != RefKind.None || !RequiresRefAssignableVariable(valueKind)); 1431if (parameterSymbol.RefKind == RefKind.None && 1435Debug.Assert(backingField.RefKind == RefKind.None); 1440Debug.Assert(backingField.RefKind == RefKind.None); 1542{ RefKind: RefKind.None } => SafeContext.CurrentMethod, 1577Debug.Assert(parameterSymbol.RefKind == RefKind.None || isRefScoped || refSafeToEscape.IsReturnOnly); 1627if ((fieldSymbol.RefKind == RefKind.None ? RequiresAssignableVariable(valueKind) : RequiresRefAssignableVariable(valueKind)) && 1639case RefKind.None: 1663case RefKind.None: 1687case RefKind.None: 1790if (fieldSymbol.RefKind != RefKind.None) 1814if (fieldSymbol.RefKind != RefKind.None) 1958if (RequiresVariable(valueKind) && methodSymbol.RefKind == RefKind.None) 2004propertySymbol.RefKind == RefKind.None) 2034var requiresSet = RequiresAssignableVariable(valueKind) && propertySymbol.RefKind == RefKind.None; 2104var requiresGet = !RequiresAssignmentOnly(valueKind) || propertySymbol.RefKind != RefKind.None; 2369(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2448result.ArgumentRefKindsOpt = [RefKind.None, .. methodInvocationInfo.ArgumentRefKindsOpt]; 2535var valid = effectiveRefKind != RefKind.None && isRefEscape ? 2597(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2728var refKind = parameter?.RefKind ?? RefKind.None; 2733if (refKind == RefKind.None && 2791return new EscapeArgument(parameter: null, receiver, RefKind.None); 2794var refKind = RefKind.None; 2821var refKind = argRefKindsOpt.IsDefault ? RefKind.None : argRefKindsOpt[argIndex]; 3034if (refKind != RefKind.None) 3054if (parameter.RefKind != RefKind.None && GetParameterRefEscapeLevel(parameter) is { } refEscapeLevel) 3118if (parameter.RefKind != RefKind.None && !parameter.IsThis) 3402if (_underlyingParameter.RefKind is not RefKind.None and var underlyingRefKind) 3409return RefKind.None; 3624Debug.Assert(field.RefKind == RefKind.None ? RequiresAssignableVariable(kind) : RequiresRefAssignableVariable(kind)); 3826if (methodSymbol.RefKind == RefKind.None) 3841if (methodSymbol.RefKind == RefKind.None) 3886if (methodSymbol.RefKind == RefKind.None) 3906Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None); 3914Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None); 3945conversion.Conversion.Method.RefKind == RefKind.None)); 3952unaryMethod.RefKind == RefKind.None)); 3959binaryMethod.RefKind == RefKind.None)); 3965logicalOperator.LogicalOperator.RefKind == RefKind.None)); 3972compoundMethod.RefKind == RefKind.None)); 3979incrementMethod.RefKind == RefKind.None)); 4112if (methodSymbol.RefKind == RefKind.None) 4131if (indexerSymbol.RefKind == RefKind.None) 4155if (indexerSymbol.RefKind == RefKind.None) 4179if (methodSymbol.RefKind == RefKind.None) 4203Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None); 4211Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None); 4226if (signature.RefKind == RefKind.None) 4243if (propertySymbol.RefKind == RefKind.None) 4283conversion.Conversion.Method.RefKind == RefKind.None); 4290unaryMethod.RefKind == RefKind.None)); 4297binaryMethod.RefKind == RefKind.None)); 4303logicalOperator.LogicalOperator.RefKind == RefKind.None)); 4310compoundMethod.RefKind == RefKind.None)); 4317incrementMethod.RefKind == RefKind.None)); 5015var accessorKind = property.RefKind == RefKind.None ? AccessorKind.Set : AccessorKind.Get; 5724resultRefKind = RefKind.None; 5725parameterRefKind = RefKind.None; 5738resultRefKind = RefKind.None; 5799RefKind.None,
Binder\Binder_AnonymousTypes.cs (1)
96RefKind.None,
Binder\Binder_Attributes.cs (2)
484BindArgumentExpression(diagnostics, argument.Expression, RefKind.None, allowArglist: false), 486refKind: RefKind.None);
Binder\Binder_Conversions.cs (6)
1433argumentRefKinds = argumentRefKinds.Add(RefKind.None); 1554if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 3533{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 3582: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 3587if (sourceRefKind != RefKind.None)
Binder\Binder_Crefs.cs (4)
282refKind: RefKind.None, 313refKind: RefKind.None, 995refKind: RefKind.None, 1012refKind: RefKind.None,
Binder\Binder_Expressions.cs (28)
491if (field is { IsStatic: false, RefKind: RefKind.None, ContainingSymbol: SourceMemberContainerTypeSymbol { PrimaryConstructor: { } primaryConstructor } } && 2040if (refKind != RefKind.None || type.IsRestrictedType()) 2122if (parameter.RefKind != RefKind.None) 2142(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2145if (parameter.RefKind != RefKind.None) 2159else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } && 2312if (localSymbol.RefKind == RefKind.None && type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2618if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3176RefKind refKind = origRefKind == RefKind.None || RefMustBeObeyed(isDelegateCreation, argumentSyntax) ? origRefKind : RefKind.None; 3189if (!hadError && isDelegateCreation && origRefKind != RefKind.None && result.Arguments.Count == 1) 3417if (refKind != RefKind.None) 3427result.RefKinds.Add(RefKind.None); 3478refKind == RefKind.None ? 3867refKind = RefKind.None; 3989if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 4013else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 8590extensionMethodArguments.RefKinds.Add(RefKind.None); 9196fieldSymbol.RefKind != RefKind.None) 10203if (refKind != RefKind.None) 10672original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }) 10773original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 10774original.Parameters[1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 10837getMethod.RefKind == RefKind.None && 11499if (returnsVoid && returnRefKind != RefKind.None) 11513returnRefKind == RefKind.None && 11515(parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)) && 11549parameterRefKinds.IsDefault ? RefKind.None : parameterRefKinds[i],
Binder\Binder_InterpolatedString.cs (2)
716refKindsBuilder.Add(RefKind.None); 717refKindsBuilder.Add(RefKind.None);
Binder\Binder_Invocation.cs (6)
301else if (analyzedArguments.RefKind(i) == RefKind.None) 308case RefKind.None: 1290Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1373CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1619argumentRefKindsBuilder.Add(RefKind.None); 1644argumentRefKindsBuilder.Add(RefKind.None);
Binder\Binder_Lambda.cs (2)
51RefKind returnRefKind = RefKind.None; 222if (refKindsBuilder.Any(r => r != RefKind.None))
Binder\Binder_Operators.cs (5)
450analyzedArguments.RefKinds.Add(RefKind.None); 3838(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3901(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4242if (parameterSymbol.RefKind != RefKind.None) 4273return localSymbol.RefKind != RefKind.None;
Binder\Binder_Patterns.cs (3)
84RefKind: RefKind.None, 136RefKind: RefKind.None, 190RefKind: RefKind.None,
Binder\Binder_Query.cs (3)
701return lambdaBodyBinder.CreateBlockFromExpression(node, ImmutableArray<LocalSymbol>.Empty, RefKind.None, construction, null, d); 781return this.CreateBlockFromExpression(expression, locals, RefKind.None, result, expression, diagnostics); 823new AnonymousTypeField(fieldName, fieldValue.Syntax.Location, TypeWithAnnotations.Create(TypeOrError(fieldValue)), RefKind.None, ScopedKind.None);
Binder\Binder_Statements.cs (20)
922RefKind expressionRefKind = RefKind.None; 924if (variableRefKind == RefKind.None) 1005if (localSymbol.RefKind != RefKind.None) 1071localSymbol.RefKind != RefKind.None ? ConversionForAssignmentFlags.RefAssignment : ConversionForAssignmentFlags.None); 2194if (delegateRefKind == RefKind.None) 3032refKind = RefKind.None; 3038var refKind = RefKind.None; 3067if (refKind != RefKind.None) 3079else if ((object)retType != null && (refKind != RefKind.None) != (sigRefKind != RefKind.None)) 3081var errorCode = refKind != RefKind.None 3190Debug.Assert(returnRefKind == RefKind.None); 3212if (returnRefKind != RefKind.None) 3520if (IsInAsyncMethod() && refKind != RefKind.None) 3529if ((refKind != RefKind.None) != (returnRefKind != RefKind.None) && expression.Kind != BoundKind.ThrowExpression) 3531var errorCode = refKind != RefKind.None 3536statement = new BoundReturnStatement(syntax, RefKind.None, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true }; 3669return bodyBinder.CreateBlockFromExpression(body, bodyBinder.GetDeclaredLocalsForScope(body), RefKind.None, expression, body, diagnostics); 3675if (refKind != RefKind.None)
Binder\DecisionDagBuilder.cs (1)
673RefKind: RefKind.None,
Binder\ExecutableCodeBinder.cs (2)
115if (parameter.RefKind != RefKind.None) 146if (refKind != RefKind.None)
Binder\ForEachLoopBinder.cs (3)
333if (local.RefKind != RefKind.None) 346case RefKind.None: 1216patternDisposeMethod.ParameterRefKinds.All(static refKind => refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));
Binder\InMethodBinder.cs (2)
149if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType) 180if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType)
Binder\LockBinder.cs (1)
84if (enterScopeMethod is not { ReturnsVoid: false, RefKind: RefKind.None })
Binder\RefSafetyAnalysis.cs (4)
554Debug.Assert(localSymbol.RefKind == RefKind.None || 568if (localSymbol.RefKind != RefKind.None) 585ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1286AddLocalScopes(local, refEscapeScope: local.RefKind == RefKind.None ? _localScopeDepth : collectionEscape, valEscapeScope: collectionEscape);
Binder\Semantics\Conversions\ConversionsBase.cs (1)
3439case RefKind.None:
Binder\Semantics\Operators\BinaryOperatorOverloadResolution.cs (4)
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 (2)
108return RefKind.None; 130return RefKind.None;
Binder\Semantics\Operators\UnaryOperatorOverloadResolution.cs (2)
486if (op1.RefKind == RefKind.None && op2.RefKind == RefKind.In) 490else if (op2.RefKind == RefKind.None && op1.RefKind == RefKind.In)
Binder\Semantics\Operators\UnaryOperatorSignature.cs (1)
62return RefKind.None;
Binder\Semantics\OverloadResolution\AnalyzedArguments.cs (2)
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))
Binder\Semantics\OverloadResolution\MethodTypeInference.cs (5)
444return _formalParameterRefKinds.IsDefault ? RefKind.None : _formalParameterRefKinds[index]; 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 (22)
875else if (returnRefKind == RefKind.None) 2644if (refKind1 == RefKind.None && isAcceptableRefMismatch(refKind2, isInterpolatedStringHandlerConversion)) 2655else if (refKind2 == RefKind.None && isAcceptableRefMismatch(refKind1, isInterpolatedStringHandlerConversion)) 2690return isExtensionParameterOfStaticExtensionMember ? RefKind.None : parameter.RefKind; 2916Debug.Assert(refKind1 == RefKind.None || refKind1 == RefKind.Ref); 2917Debug.Assert(refKind2 == RefKind.None || refKind2 == RefKind.Ref); 2921if (refKind1 == RefKind.None) 3914hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None; 3939RefKind argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 3944if (paramRefKind != RefKind.None) 3946refs = ArrayBuilder<RefKind>.GetInstance(arg, RefKind.None); 3978if (argRefKind == RefKind.None) 3980return RefKind.None; 3988else if (paramRefKind == RefKind.RefReadOnlyParameter && argRefKind is RefKind.None or RefKind.Ref or RefKind.In) 4001if ((options & Options.AllowRefOmittedArguments) != 0 && paramRefKind == RefKind.Ref && argRefKind == RefKind.None && !binder.InAttributeArgument) 4004return RefKind.None; 4092var argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 4096if (paramRefKind != RefKind.None) 4575RefKind parameterRefKind = parameters.ParameterRefKinds.IsDefault ? RefKind.None : parameters.ParameterRefKinds[argumentPosition]; 4580if (argumentRefKind == RefKind.None) 4736Debug.Assert(argRefKind != RefKind.None); 4742if (argRefKind == RefKind.None || hasInterpolatedStringRefMismatch)
Binder\Semantics\OverloadResolution\OverloadResolutionResult.cs (5)
1161if (parameters[i].RefKind != RefKind.None) 1235Debug.Assert(refArg == RefKind.None); 1294!(refArg == RefKind.None && refParameter == RefKind.In) && 1296!(refParameter == RefKind.RefReadOnlyParameter && refArg is RefKind.None or RefKind.Ref or RefKind.In)) 1317else if (refParameter is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)
BoundTree\BoundExpressionExtensions.cs (4)
60return RefKind.None; 66return RefKind.None; 72EventSymbol => RefKind.None, 77return RefKind.None;
BoundTree\BoundReturnStatement.cs (1)
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 (4)
63fieldSymbol.RefKind != RefKind.None || 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 &&
BoundTree\UnboundLambda.cs (8)
188parameterRefKinds.IsDefault ? Enumerable.Repeat(RefKind.None, parameterTypes.Length).ToImmutableArray() : parameterRefKinds, 219RefKind refKind = RefKind.None; 223if (rk != RefKind.None) 681refKind = CodeAnalysis.RefKind.None; 845refKind == CodeAnalysis.RefKind.None && 1280refKind = CodeAnalysis.RefKind.None; 1607return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1641statements[0] is BoundReturnStatement { RefKind: Microsoft.CodeAnalysis.RefKind.None, ExpressionOpt: BoundExpression expr })
CodeGen\CodeGenerator.cs (1)
172var slotConstraints = _method.RefKind == RefKind.None
CodeGen\CodeGenerator_HasHome.cs (2)
94return !((CodeGenerator.IsStackLocal(local, stackLocalsOpt) && local.RefKind == RefKind.None) || 216Debug.Assert(field.RefKind == RefKind.None);
CodeGen\CodeGenerator_RefSafety.cs (3)
29returnRefKind: RefKind.None, 73if (used && (returnRefKind != RefKind.None || returnType.IsRefLikeOrAllowsRefLikeType())) 105else if (parameter.RefKind != RefKind.None && parameter.EffectiveScope == ScopedKind.None)
CodeGen\EmitAddress.cs (5)
36Debug.Assert(((BoundDup)expression).RefKind != RefKind.None, "taking address of a stack value?"); 274if (local.RefKind != RefKind.None) 480if (parameterSymbol.RefKind == RefKind.None) 554field.RefKind == RefKind.None ? 558_builder.EmitOpCode(field.RefKind == RefKind.None ? ILOpCode.Ldflda : ILOpCode.Ldfld);
CodeGen\EmitExpression.cs (35)
710RefKind refKind = expression.ArgumentRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : expression.ArgumentRefKindsOpt[i]; 719case RefKind.None: 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"); 742case RefKind.None: 790if (expression.RefKind == RefKind.None) 962Debug.Assert(parameters.All(p => p.RefKind == RefKind.None) || !argRefKindsOpt.IsDefault, "there are nontrivial parameters, so we must have argRefKinds"); 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) 2246return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 2249return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 2252return ((BoundCall)receiver).Method.RefKind != RefKind.None; 2255return ((BoundFunctionPointerInvocation)receiver).FunctionPointer.Signature.RefKind != RefKind.None; 2258return ((BoundDup)receiver).RefKind != RefKind.None; 2670if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2801return ((BoundParameter)left).ParameterSymbol.RefKind == RefKind.None; 2806return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None; 2826if (left.FieldSymbol.RefKind != RefKind.None && 2844if (left.ParameterSymbol.RefKind != RefKind.None && 2876if (left.LocalSymbol.RefKind != RefKind.None && !assignmentOperator.IsRef) 2975Debug.Assert(left.Method.RefKind != RefKind.None); 2986Debug.Assert(left.FunctionPointer.Signature.RefKind != RefKind.None); 3121if (local.LocalSymbol.RefKind != RefKind.None && !assignment.IsRef) 3154Debug.Assert(((BoundDup)expression).RefKind != RefKind.None); 3177Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None); 3182Debug.Assert(((BoundFunctionPointerInvocation)expression).FunctionPointer.Signature.RefKind != RefKind.None); 3326if (field.RefKind != RefKind.None && !refAssign) 3341if (parameter.ParameterSymbol.RefKind != RefKind.None && !refAssign) 4138if (useKind == UseKind.UsedAsValue && method.RefKind != RefKind.None) 4144Debug.Assert(method.RefKind != RefKind.None);
CodeGen\EmitStatement.cs (9)
759Debug.Assert(local.RefKind == RefKind.None || local.SynthesizedKind.IsLongLived(), 875if (boundReturnStatement.RefKind == RefKind.None) 1170Debug.Assert(exceptionSourceLocal.LocalSymbol.RefKind == RefKind.None); 1182Debug.Assert(left.FieldSymbol.RefKind == RefKind.None); 1310if (local.RefKind == RefKind.None && !IsStackLocal(local)) 1319if (parameter.ParameterSymbol.RefKind == RefKind.None) 1793CSharpCompilation.DynamicTransformsEncoder.Encode(local.Type, RefKind.None, 0) : 1823Debug.Assert(local.RefKind == RefKind.None); 1839(local.RefKind != RefKind.None ? LocalSlotConstraints.ByRef : LocalSlotConstraints.None);
CodeGen\Optimizer.cs (14)
857if (node.LocalSymbol.RefKind != RefKind.None) 877if (node.LocalSymbol.RefKind != RefKind.None) 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) 1230if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1283ExprContext context = (argRefKind == RefKind.None) ? ExprContext.Value : ExprContext.Address; 1309RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1437if (localSym.RefKind == RefKind.None) 1885Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1946return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2221var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2489get { return RefKind.None; }
Compilation\CSharpCompilation.cs (2)
2329if (method.RefKind != RefKind.None) 4427fields.Add(new AnonymousTypeField(name, location, TypeWithAnnotations.Create(type, nullableAnnotation), RefKind.None, ScopedKind.None));
Compiler\MethodBodySynthesizer.cs (4)
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 (2)
671return parameter.RefKind is RefKind.None == other.RefKind is RefKind.None &&
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 (12)
1341VisitRvalue(node.InitializerOpt, isKnownToBeAnLvalue: node.LocalSymbol.RefKind != RefKind.None); 1344if (node.LocalSymbol.RefKind != RefKind.None) 1580VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1600case RefKind.None: 1624return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index]; 2081VisitRvalue(node.ExpressionOpt, isKnownToBeAnLvalue: node.RefKind != RefKind.None); 2084if (node.RefKind != RefKind.None) 2195if (property.RefKind == RefKind.None) 2250if (property.RefKind == RefKind.None) 2269if (property.RefKind == RefKind.None) 2886if (property.RefKind == RefKind.None) 3805property.RefKind == RefKind.None)
FlowAnalysis\DataFlowsOutWalker.cs (1)
233((param.RefKind != RefKind.None && !param.IsImplicitlyDeclared && !RegionContains(param.GetFirstLocation().SourceSpan)) ||
FlowAnalysis\DefiniteAssignment.cs (11)
350NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 811write: field.RefKind == RefKind.None || isRef); 924write: field.RefKind == RefKind.None || isRef); 1287if (fieldSymbol.RefKind != RefKind.None) 1471if (!isRef && node is BoundFieldAccess { FieldSymbol.RefKind: not RefKind.None } fieldAccess) 1524if (local.LocalSymbol.RefKind != RefKind.None && !isRef) 1593write: field.RefKind == RefKind.None || isRef); 1852NoteWrite(parameter, value: null, read: true, isRef: parameter.RefKind != RefKind.None); 1922if (parameter.RefKind != RefKind.None) 2540if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2732NoteWrite(iterationVariable, null, read: true, isRef: iterationVariable.RefKind != RefKind.None);
FlowAnalysis\FlowAnalysisPass.cs (3)
85var newStatements = block.Statements.Add(new BoundReturnStatement(trailingExpression.Syntax, RefKind.None, trailingExpression, @checked: false)); 141if (field.RefKind == RefKind.None) 205: BoundReturnStatement.Synthesized(syntax, RefKind.None, null);
FlowAnalysis\NullableWalker.cs (17)
2506return AreParameterAnnotationsCompatible(RefKind.None, overriddenType, overriddenAnnotations, overridingType, overridingAnnotations, forRef: true) && 2510if (refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter) 3078if (node.RefKind == RefKind.None && 3087if (node.RefKind == RefKind.None) 7013if (receiverRefKind == RefKind.None) 7018var builder = ArrayBuilder<RefKind>.GetInstance(argumentCount + 1, fillWithValue: RefKind.None); 7033return extensionParameter.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.None; 7827refKindsBuilder.AddMany(RefKind.None, elements.Length); 7954RefKind: RefKind.None, 8107case RefKind.None: 8168case RefKind.None: 8303case RefKind.None: 8449RefKind: RefKind.None, 8582if (refKind == RefKind.None) 11324case BoundLocal { LocalSymbol.RefKind: RefKind.None }: 11325case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameter } when 13551TypeWithAnnotations elementType = InMethodBinder.GetIteratorElementTypeFromReturnType(compilation, RefKind.None,
FlowAnalysis\NullableWalker.PlaceholderLocal.cs (1)
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)
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\RuntimeAsyncRewriter.cs (1)
56if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None })
Lowering\ClosureConversion\ClosureConversion.cs (2)
567new BoundReturnStatement(syntax, RefKind.None, null, @checked: false)); 927refkindsBuilder.AddMany(RefKind.None, arguments.Length);
Lowering\ClosureConversion\LambdaCapturedVariable.cs (1)
139public override RefKind RefKind => RefKind.None;
Lowering\DiagnosticsPass_ExpressionTrees.cs (3)
358else if (method.RefKind != RefKind.None) 579if (_inExpressionLambda && property.RefKind != RefKind.None) 621if (p.RefKind != RefKind.None && p.TryGetFirstLocation() is Location location)
Lowering\DiagnosticsPass_Warnings.cs (3)
28if (argumentRefKindsOpt[i] != RefKind.None) 244if (method.Parameters[i].RefKind != RefKind.None && (argumentRefKindsOpt.IsDefault || argumentRefKindsOpt[i] == RefKind.None)) return true;
Lowering\ExtensionMethodReferenceRewriter.cs (2)
109if (receiverRefKind != RefKind.None) 111var builder = ArrayBuilder<RefKind>.GetInstance(method.ParameterCount, RefKind.None);
Lowering\Extensions.cs (1)
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\LocalStateTracingInstrumenter.cs (1)
455Debug.Assert(parameter.RefKind == RefKind.None);
Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (3)
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 (1)
142get { return RefKind.None; }
Lowering\LocalRewriter\LocalRewriter.cs (3)
1101return ((BoundCall)expr).Method.RefKind != RefKind.None; 1104return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1107return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None;
Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)
555&& loweredInput.GetRefKind() == RefKind.None &&
Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.cs (4)
234Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None); 328(arguments.Length != 0 || !IsSafeForReordering(rewrittenRight, RefKind.None))) 367if (!IsSafeForReordering(rewrittenRight, RefKind.None)) 369BoundLocal capturedRight = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter_Call.cs (23)
303if (thisRefKind != RefKind.None 320if (argumentRefKindsOpt.IsDefault && thisRefKind != RefKind.None) 579return kind != RefKind.None; 707refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None; 713refKind = RefKind.None; 719if (refKind == RefKind.None && 956bool isReceiverTakenByValue = receiverRefKind == RefKind.None; 961return RefKind.None; 975return RefKind.None; 989return RefKind.None; 1147ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 1223var currentArgRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i]; 1254refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameters.Length, fillWithValue: RefKind.None); 1270Debug.Assert(initialArgRefKind is RefKind.None or RefKind.In or RefKind.Ref); 1271return initialArgRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn; 1273else if (paramRefKind == RefKind.Ref && initialArgRefKind == RefKind.None) 1345if (refKind != RefKind.None) 1428Debug.Assert(argRefKind == RefKind.None); 1444arg.rewriter.StoreArgumentToTempIfNecessary(arg.forceLambdaSpilling, arg.storesToTemps, element, RefKind.None, RefKind.None), 1473? (argRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn) 1705if (argRefKind != RefKind.None || paramRefKind != RefKind.Ref) 1720Debug.Assert(localRefKind == RefKind.None);
Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (14)
233BoundLocal binaryResult = _factory.StoreToTemp(opFinal, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 258return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false }; 313refKind = variableRepresentsLocation ? RefKind.Ref : RefKind.None; 483ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 556Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None); 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) 830Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 834Debug.Assert(((BoundFunctionPointerInvocation)originalLHS).FunctionPointer.Signature.RefKind != RefKind.None); 985((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None || 989return localsMayBeAssignedOrCaptured || ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None;
Lowering\LocalRewriter\LocalRewriter_DeconstructionAssignmentOperator.cs (2)
168case BoundLocal { LocalSymbol: { RefKind: RefKind.None } localSymbol }: 171case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameterSymbol }:
Lowering\LocalRewriter\LocalRewriter_FixedStatement.cs (1)
36if (pinnedTemp.RefKind == RefKind.None)
Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)
618RefKind collectionTempRefKind = RefKind.None;
Lowering\LocalRewriter\LocalRewriter_IndexerAccess.cs (4)
119if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 568receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref); 633if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 871receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref);
Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (1)
47BoundLocal rightResult = _factory.StoreToTemp(loweredRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)
146if (unwrappedRight is { ConstantValueOpt: not null } or BoundLocal { LocalSymbol.IsRef: false } or BoundParameter { ParameterSymbol.RefKind: RefKind.None } &&
Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)
186.All(p => p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 208var builder = ArrayBuilder<RefKind>.GetInstance(addMethod.Parameters.Length, RefKind.None); 642elementArg.rewriter.EvaluateSideEffects(element, RefKind.None, elementArg.sideeffects, ref elementArg.temps),
Lowering\LocalRewriter\LocalRewriter_PropertyAccess.cs (1)
52if (isLeftOfAssignment && propertySymbol.RefKind == RefKind.None)
Lowering\LocalRewriter\LocalRewriter_StringInterpolation.cs (1)
51Debug.Assert(construction.ArgumentRefKindsOpt[i] == RefKind.None);
Lowering\LocalRewriter\LocalRewriter_UnaryOperator.cs (3)
637return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 641return ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None; 669BoundLocal incrementResult = _factory.StoreToTemp(newValue, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter_UsingStatement.cs (2)
500Debug.Assert(method.Parameters.AsSpan()[1..].All(static (p) => (p.IsOptional || p.IsParams) && p.RefKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter)); 507Debug.Assert(method.ParameterRefKinds.IsDefaultOrEmpty || method.ParameterRefKinds.All(static refKind => refKind is RefKind.In or RefKind.RefReadOnlyParameter or RefKind.None));
Lowering\LocalRewriter\LoweredDynamicOperationFactory.cs (22)
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); 229receiverRefKind = RefKind.None; 293return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, default(ImmutableArray<RefKind>), loweredHandler, resultType); 330return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, refKinds, null, resultType); 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); 459return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, loweredArguments, refKinds, null, resultType); 517return MakeDynamicOperation(binderConstruction, loweredReceiver, RefKind.None, ImmutableArray<BoundExpression>.Empty, default(ImmutableArray<RefKind>), null, resultType); 548return RefKind.None; 556return hasHome ? RefKind.Ref : RefKind.None; 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); 737bool hasByRefs = receiverRefKind != RefKind.None || !refKinds.IsDefaultOrEmpty; 777byRefs[j++] = RefKind.None; 795return refKind == RefKind.None ? RefKind.None : RefKind.Ref; 818Debug.Assert(refKind == RefKind.None || refKind == RefKind.Ref || refKind == RefKind.Out, "unexpected refKind in dynamic");
Lowering\MethodToClassRewriter.cs (1)
268if (leftLocal.LocalSymbol.RefKind != RefKind.None &&
Lowering\SpillSequenceSpiller.cs (27)
305RefKind refKind = RefKind.None, 317Debug.Assert(refKind == RefKind.None); 324Debug.Assert(refKind == RefKind.None); 337if (refKind != RefKind.None || expression.Type?.IsRefLikeOrAllowsRefLikeType() == true) 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 635var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 903expression = Spill(leftBuilder, expression, RefKind.None); 950expression = Spill(leftBuilder, expression, RefKind.None); 1047Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1051if (refKind != RefKind.None && 1086var result = RefKind.None; 1299if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1302receiver = Spill(receiverBuilder, receiver, RefKind.None); 1319var 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 (15)
155refKind: RefKind.None, 171refKind: RefKind.None, 192if (refKind != RefKind.None || field.FieldSymbol.IsReadOnly) return expr; 197if (refKind == RefKind.None) 207refKind: isFieldOfStruct ? refKind : RefKind.None, 238if (refKind != RefKind.None && refKind != RefKind.In) 241if (call.Method.RefKind != RefKind.None) 248refKind = RefKind.None; 259if (refKind != RefKind.None && refKind != RefKind.RefReadOnly) 267refKind = RefKind.None; 276if (refKind != RefKind.None) 285Debug.Assert(_reportedError || expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 286or BoundParameter { ParameterSymbol.RefKind: RefKind.None }); 290if (expr is BoundLocal { LocalSymbol.RefKind: RefKind.None } 291or BoundParameter { ParameterSymbol.RefKind: RefKind.None })
Lowering\StateMachineRewriter\StateMachineFieldSymbol.cs (1)
64public override RefKind RefKind => RefKind.None;
Lowering\StateMachineRewriter\StateMachineRewriter.cs (2)
171if (local.RefKind != RefKind.None) 179Debug.Assert(local.RefKind == RefKind.None);
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)
43get { return RefKind.None; }
Lowering\SyntheticBoundNodeFactory.cs (9)
575Debug.Assert(CurrentFunction.RefKind == RefKind.None); 580return new BoundReturnStatement(Syntax, CurrentFunction.RefKind != RefKind.None ? RefKind.Ref : RefKind.None, expression, @checked: false) { WasCompilerGenerated = true }; 600RefKind refKind = RefKind.None, 640return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 1647RefKind refKind = RefKind.None, 1678refKind = RefKind.None; 1682case RefKind.None: 1714isRef: refKind != RefKind.None);
Operations\CSharpOperationFactory.cs (1)
899MethodSymbol? accessor = isObjectOrCollectionInitializer || property.RefKind != RefKind.None
SymbolDisplay\SymbolDisplayVisitor.Members.cs (1)
873symbol.RefKind == RefKind.None &&
Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)
253if (fields.Any(static f => f.RefKind != RefKind.None))
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (2)
33paramsArr.Add(SynthesizedParameterSymbol.Create(this, property.TypeWithAnnotations, index, RefKind.None, property.Name)); 55get { return RefKind.None; }
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.DelegateTemplateSymbol.cs (2)
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];
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.EqualsMethodSymbol.cs (2)
25SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(this.Manager.System_Object), 0, RefKind.None, "value")); 40get { return RefKind.None; }
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.FieldSymbol.cs (1)
35public override RefKind RefKind => RefKind.None;
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.GetHashCodeMethodSymbol.cs (1)
44get { return RefKind.None; }
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertyAccessorSymbol.cs (1)
41get { return RefKind.None; }
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertySymbol.cs (1)
66get { return RefKind.None; }
Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ToStringMethodSymbol.cs (1)
44get { return RefKind.None; }
Symbols\BaseTypeAnalysis.cs (1)
203if (field.RefKind != RefKind.None)
Symbols\Compilation_WellKnownMembers.cs (7)
817internal SynthesizedAttributeData? SynthesizeDynamicAttribute(TypeSymbol type, int customModifiersCount, RefKind refKindOpt = RefKind.None) 822if (type.IsDynamic() && refKindOpt == RefKind.None && customModifiersCount == 0) 961if (refKind != RefKind.None) 1059if (refKind != RefKind.None) 1214return parameter.RefKind != RefKind.None; 1219return method.RefKind != RefKind.None; 1224return property.RefKind != RefKind.None;
Symbols\ErrorMethodSymbol.cs (1)
162get { return RefKind.None; }
Symbols\ErrorPropertySymbol.cs (1)
44public override RefKind RefKind { get { return RefKind.None; } }
Symbols\Extensions\SynthesizedExtensionMarker.cs (2)
25MethodKind.Ordinary, RefKind.None, GetDeclarationModifiers(), returnsVoid: false, returnsVoidIsSet: false, 110if (parameter.Name is "" && parameterRefKind != RefKind.None)
Symbols\FieldSymbol.cs (1)
358if (DeriveUseSiteInfoFromType(ref result, this.TypeWithAnnotations, RefKind == RefKind.None ? AllowedRequiredModifierType.System_Runtime_CompilerServices_Volatile : AllowedRequiredModifierType.None) ||
Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (15)
28RefKind refKind = RefKind.None; 44case SyntaxKind.RefKeyword when refKind == RefKind.None: 59Debug.Assert(refKind != RefKind.None); 73if (returnType.IsVoidType() && refKind != RefKind.None) 88if (refKind != RefKind.None) 285if (returnRefKind == RefKind.None) 312Debug.Assert(refKind is RefKind.None or RefKind.In or RefKind.Ref or RefKind.Out); 351var returnVariance = RefKind == RefKind.None ? variance : VarianceKind.None; 366(VarianceKind.In, RefKind.None) => VarianceKind.Out, 367(VarianceKind.Out, RefKind.None) => VarianceKind.In, 497Debug.Assert(refCustomModifiers.IsDefaultOrEmpty || refKind != RefKind.None); 509Debug.Assert(refCustomModifiers.IsEmpty || refKind != RefKind.None); 585false => RefKind.None, 648var modifiersToSearch = RefKind != RefKind.None ? RefCustomModifiers : ReturnTypeWithAnnotations.CustomModifiers; 671var modifiersToSearch = RefKind != RefKind.None ? RefCustomModifiers : ReturnTypeWithAnnotations.CustomModifiers;
Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (4)
192? (refKind1 == RefKind.None) == (refKind2 == RefKind.None) 202=> refKind == RefKind.None ? RefKind.None : RefKind.Ref;
Symbols\LocalSymbol.cs (1)
375public bool IsRef => RefKind != RefKind.None;
Symbols\MemberSignatureComparer.cs (2)
799if ((refKind1 == RefKind.None) != (refKind2 == RefKind.None))
Symbols\Metadata\PE\DynamicTypeDecoder.cs (2)
69RefKind targetSymbolRefKind = RefKind.None) 212return refKind == RefKind.None || !ConsumeFlag();
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 (2)
328RefKind.None; 658if (RefKind != RefKind.None &&
Symbols\Metadata\PE\PEMethodSymbol.cs (2)
1158case RefKind.None: 1189case RefKind.None:
Symbols\Metadata\PE\PEParameterSymbol.cs (3)
259RefKind refKind = RefKind.None; 265refKind = isByRef ? RefKind.Ref : RefKind.None; 334Debug.Assert(refKind != RefKind.None);
Symbols\Metadata\PE\PEPropertySymbol.cs (2)
313_refKind = RefKind.None; 399if (this.RefKind != RefKind.None && _setMethod != null)
Symbols\NamedTypeSymbol.cs (1)
1842return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] };
Symbols\ParameterSignature.cs (2)
49if (refKind != RefKind.None) 51refs = ArrayBuilder<RefKind>.GetInstance(parm, RefKind.None);
Symbols\ParameterSymbol.cs (1)
167((refKind = RefKind) == RefKind.None ||
Symbols\RefKindExtensions.cs (3)
18return refKind != RefKind.None; 32return RefKind.None; 45case RefKind.None:
Symbols\Source\CustomModifierUtils.cs (3)
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\GlobalExpressionVariable.cs (1)
69public sealed override RefKind RefKind => RefKind.None;
Symbols\Source\LocalFunctionSymbol.cs (1)
301Debug.Assert(_refKind == RefKind.None
Symbols\Source\ParameterHelpers.cs (6)
904else if (refKind != RefKind.None && 1145var refKind = RefKind.None; 1157if (refKind == RefKind.None) 1164if (refKind == RefKind.None) 1171if (refKind == RefKind.None) 1200scope = (refKind == RefKind.None) ? ScopedKind.ScopedValue : ScopedKind.ScopedRef;
Symbols\Source\SourceAssemblySymbol.cs (1)
2746else if (field.RefKind != RefKind.None)
Symbols\Source\SourceComplexParameterSymbol.cs (2)
910return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 1805Debug.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 (8)
221: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 224SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 225SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 361: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 371parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 372parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 410if (p.RefKind != RefKind.None) 417parameters.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 (1)
59public sealed override RefKind RefKind => RefKind.None;
Symbols\Source\SourceEventAccessorSymbol.cs (1)
37RefKind.None,
Symbols\Source\SourceLocalSymbol.cs (1)
100_scope = _refKind != RefKind.None
Symbols\Source\SourceMemberContainerSymbol.cs (14)
4529if (methodParam.RefKind != RefKind.None) 4552methodParams[0].RefKind == RefKind.None && 5027RefKind.None, 5073RefKind.None 5075RefKind.None, 5126RefKind.None)), 5127RefKind.None, 5182RefKind.None, 5261RefKind.None, 5356RefKind.None, 5387RefKind.None, 5453RefKind.None 5455RefKind.None, 5661var modifiers = SourceMemberFieldSymbol.MakeModifiers(this, fieldSyntax.Declaration.Variables[0].Identifier, fieldSyntax.Modifiers, isRefField: refKind != RefKind.None, diagnostics, out modifierErrors);
Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (1)
1460else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))
Symbols\Source\SourceMemberFieldSymbol.cs (6)
462RefKind refKind = RefKind.None; 500Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 502if (refKind != RefKind.None) 519Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error 550var initializerOpt = executableBinder.BindInferredVariableInitializer(diagnostics, RefKind.None, syntaxNode, declarator); 579if (refKind != RefKind.None)
Symbols\Source\SourceMethodSymbol.cs (1)
69if (parameter.RefKind != RefKind.None)
Symbols\Source\SourceMethodSymbolWithAttributes.cs (2)
1419if (refKind != RefKind.None) 1542if (this.RefKind != RefKind.None)
Symbols\Source\SourceNamedTypeSymbol_Extension.cs (3)
316if (signature.RefKind != RefKind.None) 334if (parameter.RefKind != RefKind.None) 752RefKind.None => "",
Symbols\Source\SourceOrdinaryMethodSymbol.cs (1)
155Debug.Assert(this.RefKind == RefKind.None || !returnType.IsVoidType() || returnTypeSyntax.HasErrors);
Symbols\Source\SourcePropertySymbolBase.cs (5)
251_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 883if (RefKind != RefKind.None && IsRequired) 907if (this.RefKind != RefKind.None) 944if (_refKind != RefKind.None) 971else if (RefKind != RefKind.None)
Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (3)
41methodKind, RefKind.None, declarationModifiers, 415case RefKind.None: 473if (p.RefKind != RefKind.None && p.RefKind != RefKind.In)
Symbols\Source\ThisParameterSymbol.cs (1)
159return RefKind.None;
Symbols\SymbolExtensions.cs (3)
482refKind = RefKind.None; 500refKind = RefKind.None; 517refKind = RefKind.None;
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListConstructor.cs (1)
15SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, parameterName));
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListEnumeratorConstructor.cs (1)
15SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, "item"));
Symbols\Synthesized\ReadOnlyListType\SynthesizedReadOnlyListProperty.cs (1)
33public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (1)
44RefKind.None,
Symbols\Synthesized\Records\SynthesizedPrimaryConstructorParameterBackingFieldSymbol.cs (1)
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\SynthesizedRecordEqualityContractProperty.cs (1)
41RefKind.None,
Symbols\Synthesized\Records\SynthesizedRecordEqualityOperator.cs (1)
45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None &&
Symbols\Synthesized\Records\SynthesizedRecordEqualityOperatorBase.cs (2)
75ordinal: 0, RefKind.None, "left", Locations), 78ordinal: 1, RefKind.None, "right", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)
41ordinal: 0, RefKind.None, "other", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordObjEquals.cs (1)
37ordinal: 0, RefKind.None, "obj", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordOrdinaryMethod.cs (1)
17MethodKind.Ordinary, RefKind.None, declarationModifiers, returnsVoid: false, returnsVoidIsSet: false,
Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)
98ordinal: 0, RefKind.None, "builder", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)
40RefKind.None,
Symbols\Synthesized\RefKindVector.cs (2)
46(false, false, false) => RefKind.None, 59RefKind.None => (false, false, false),
Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)
24: base(accessor, ordinal, RefKind.None, ParameterSymbol.ValueParameterName, accessor.TryGetFirstLocation(),
Symbols\Synthesized\SynthesizedBackingFieldSymbol.cs (1)
96Debug.Assert(property.RefKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly);
Symbols\Synthesized\SynthesizedDelegateSymbol.cs (2)
21SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(objectType), 0, RefKind.None, "object"), 22SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intPtrType), 1, RefKind.None, "method"));
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 (6)
117get { return RefKind.None; } 451refKind: RefKind.None, 469refKind: RefKind.None, 563RefKind.None, 582TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray")); 654RefKind.None,
Symbols\Synthesized\SynthesizedEnumValueFieldSymbol.cs (1)
29public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\SynthesizedFieldSymbol.cs (1)
36public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (1)
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\SynthesizedInlineArrayAsReadOnlySpanMethod.cs (1)
18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "length")));
Symbols\Synthesized\SynthesizedInlineArrayAsSpanMethod.cs (1)
18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "length")));
Symbols\Synthesized\SynthesizedInlineArrayElementRefMethod.cs (1)
18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "index")));
Symbols\Synthesized\SynthesizedInlineArrayElementRefReadOnlyMethod.cs (1)
18SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(intType), 1, RefKind.None, "index")));
Symbols\Synthesized\SynthesizedInstanceConstructor.cs (1)
151get { return RefKind.None; }
Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (1)
116get { return RefKind.None; }
Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (2)
221return RefKind.None; 475) : base(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, ScopedKind.None, name)
Symbols\Synthesized\SynthesizedLambdaCacheFieldSymbol.cs (1)
36public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\SynthesizedLocal.cs (1)
41RefKind refKind = RefKind.None
Symbols\Synthesized\SynthesizedPropertySymbol.cs (2)
26public override RefKind RefKind => RefKind.None; 89public override RefKind RefKind => RefKind.None;
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 (1)
131return RefKind.None;
Symbols\Synthesized\SynthesizedStringHashFunctionSymbol.cs (2)
21this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s"))); 31this.SetParameters(ImmutableArray.Create<ParameterSymbol>(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "s")));
Symbols\Synthesized\SynthesizedSubmissionConstructor.cs (1)
29SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));
Symbols\Synthesized\SynthesizedThrowSwitchExpressionExceptionMethod.cs (1)
19this.SetParameters(ImmutableArray.Create(SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(paramType), 0, RefKind.None, "unmatchedValue")));
Symbols\Synthesized\SynthesizedUnionCtor.cs (1)
26Parameters = [SynthesizedParameterSymbol.Create(this, parameterType, ordinal: 0, RefKind.None, ParameterSymbol.ValueParameterName)];
Symbols\Synthesized\SynthesizedUnionValuePropertySymbol.cs (1)
35RefKind.None,
Symbols\Tuples\TupleErrorFieldSymbol.cs (1)
157public override RefKind RefKind => RefKind.None;
Symbols\TypeSymbol.cs (2)
2027RefKind interfaceMemberRefKind = RefKind.None; 2587return elementField is { RefKind: RefKind.None, IsFixedSizeBuffer: false };
Symbols\VarianceSafety.cs (3)
166requireInputSafety: method.RefKind != RefKind.None, 202requireInputSafety: hasSetter || !(property.GetMethod?.RefKind == RefKind.None), 245requireOutputSafety: param.RefKind != RefKind.None,
Syntax\SyntaxNodeExtensions.cs (2)
283refKind = RefKind.None; 324refKind = RefKind.None;
Microsoft.CodeAnalysis.CSharp.CodeStyle (1)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ArgumentSyntaxExtensions.cs (1)
30_ => RefKind.None,
Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (6)
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)
74refKind: RefKind.None,
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateConversionService.cs (1)
209refKind: RefKind.None,
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)
35=> _invocationExpression.IsParentKind(SyntaxKind.RefExpression) ? RefKind.Ref : RefKind.None;
src\roslyn\src\Analyzers\CSharp\CodeFixes\ImplementInterface\CSharpImplementInterfaceService.cs (1)
110g.Argument(DisposingName, RefKind.None, g.FalseLiteralExpression()))));
src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)
215refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)
735return InferTypeInArgument(index, parameterizedSymbols, name, RefKind.None);
Microsoft.CodeAnalysis.CSharp.Features (12)
CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)
89refKind: dataFlow.WrittenInside.Contains(capture) ? RefKind.Ref : RefKind.None,
Completion\Providers\ContextVariableArgumentProvider.cs (1)
47case RefKind.None:
ConvertLinq\CSharpConvertLinqQueryToForEachProvider.cs (2)
304methodSymbol.RefKind == RefKind.None) 341methodSymbol.RefKind == RefKind.None &&
ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (1)
100refKind: AnalyzerResult.ReturnsByRef ? RefKind.Ref : RefKind.None,
GenerateType\CSharpGenerateTypeService.cs (1)
788refKind: RefKind.None,
InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)
250RefKind.None,
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateConstructor\CSharpGenerateConstructorService.cs (1)
74refKind: RefKind.None,
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateConversionService.cs (1)
209refKind: RefKind.None,
src\roslyn\src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateParameterizedMemberService.cs (1)
35=> _invocationExpression.IsParentKind(SyntaxKind.RefExpression) ? RefKind.Ref : RefKind.None;
src\roslyn\src\Analyzers\CSharp\CodeFixes\ImplementInterface\CSharpImplementInterfaceService.cs (1)
110g.Argument(DisposingName, RefKind.None, g.FalseLiteralExpression()))));
src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)
215refKind: RefKind.None,
Microsoft.CodeAnalysis.CSharp.NetAnalyzers (2)
Microsoft.NetCore.Analyzers\Performance\CSharpRecommendCaseInsensitiveStringComparisonFixer.cs (1)
92generator.Argument(RCISCAnalyzer.StringParameterName, RefKind.None, argumentMemberAccessExpression.Expression) :
Microsoft.NetCore.Analyzers\Runtime\CSharpPreferStreamAsyncMemoryOverloads.Fixer.cs (1)
109return generator.Argument(name: newName, RefKind.None, actualNode);
Microsoft.CodeAnalysis.CSharp.Workspaces (4)
CodeGeneration\CSharpSyntaxGenerator.cs (2)
207case RefKind.None: 3672=> this.ParameterDeclaration(identifier, type, initializer: null, RefKind.None);
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ArgumentSyntaxExtensions.cs (1)
30_ => RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)
735return InferTypeInArgument(index, parameterizedSymbols, name, RefKind.None);
Microsoft.CodeAnalysis.Extensions.Package (3)
Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
Microsoft.CodeAnalysis.Features (33)
AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.State.cs (1)
113return constructorParams.All(parameter => parameter.RefKind == RefKind.None) &&
ChangeSignature\AbstractChangeSignatureService.cs (1)
832refKind: RefKind.None,
Completion\Providers\AbstractContextVariableArgumentProvider.cs (1)
31|| context.Parameter.RefKind != RefKind.None;
ConvertToInterpolatedString\AbstractConvertPlaceholderToInterpolatedStringRefactoringProvider.cs (1)
78if (syntaxFacts.GetRefKindOfArgument(argument) != RefKind.None)
ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)
870RefKind.None,
EncapsulateField\AbstractEncapsulateFieldService.cs (1)
352refKind: RefKind.None,
ExtractMethod\MethodExtractor.CodeGenerator.cs (1)
453_ => RefKind.None
GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (1)
104where c.Parameters.All(p => p.RefKind == RefKind.None) && !c.Parameters.Any(static p => p.IsParams)
GenerateEqualsAndGetHashCodeFromMembers\AbstractGenerateEqualsAndGetHashCodeService.cs (1)
138refKind: RefKind.None,
GenerateFromMembers\GenerateFromMembersHelpers.cs (1)
104refKind: RefKind.None,
GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (1)
50RefKind.None,
InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (1)
342RefKind.None,
IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)
584? (TArgumentSyntax)_generator.Argument(parameterName, RefKind.None, newArgumentExpression)
ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)
137setMethod.Parameters is [{ RefKind: RefKind.None } parameter] &&
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)
965methodSymbol.Parameters[0].RefKind == RefKind.None &&
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
606if (symbol is IParameterSymbol { RefKind: not RefKind.None } || 607symbol is ILocalSymbol { RefKind: not RefKind.None } ||
src\roslyn\src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (2)
134RefKind: RefKind.None, 367if (property.RefKind != RefKind.None)
src\roslyn\src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)
120if (isTopLevel && symbol is IPropertySymbol { RefKind: RefKind.None })
src\roslyn\src\Analyzers\Core\Analyzers\UseConditionalExpression\ForReturn\UseConditionalExpressionForReturnHelpers.cs (2)
89syntaxFacts, anyReturn.GetRefKind(containingSymbol) != RefKind.None, 130isRef = anyReturn.GetRefKind(containingSymbol) != RefKind.None;
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)
76refKind: RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)
254refKind: RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.CodeAction.cs (2)
63var setAccessor = _isReadonly || _refKind != RefKind.None 118return _state.TypeToGenerateIn.TypeKind != TypeKind.Interface && _refKind != RefKind.None
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)
147document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None)); 161document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None)); 175document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None)); 260return RefKind.None;
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.GenerateParameterCodeAction.cs (1)
49RefKind.None,
src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_DisposePattern.cs (1)
198g.Argument(DisposingName, RefKind.None, g.TrueLiteralExpression())))));
src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)
796if ((symbol.RefKind == RefKind.None) == parameterInfo.IsRefOrOut)
Microsoft.CodeAnalysis.ResxSourceGenerator (7)
src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
185Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
Microsoft.CodeAnalysis.VisualBasic (7)
Compilation\ClsComplianceChecker.vb (1)
958builder.Add(If(parameter.IsByRef, RefKind.Ref, RefKind.None))
SymbolDisplay\SymbolDisplayVisitor.Members.vb (1)
527If symbol.RefKind <> RefKind.None AndAlso IsExplicitByRefParameter(symbol) Then
Symbols\FieldSymbol.vb (1)
457Return RefKind.None
Symbols\MethodSymbol.vb (1)
1086Return If(Me.ReturnsByRef, RefKind.Ref, RefKind.None)
Symbols\ParameterSymbol.vb (1)
308Return If(Me.IsByRef, RefKind.Ref, RefKind.None)
Symbols\PropertySymbol.vb (1)
611Return If(Me.ReturnsByRef, RefKind.Ref, RefKind.None)
Symbols\Source\LocalSymbol.vb (1)
300Return RefKind.None
Microsoft.CodeAnalysis.VisualBasic.CodeStyle (5)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb (3)
287Return parameter IsNot Nothing AndAlso parameter.RefKind <> RefKind.None 302Return method.Parameters(index).RefKind <> RefKind.None 307Return prop.Parameters(index).RefKind <> RefKind.None
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)
288parameter.RefKind <> RefKind.None Then
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)
602Return RefKind.None
Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (5)
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (1)
155refKind:=RefKind.None,
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateParameterizedMemberService.vb (2)
37Return RefKind.None 132Me.InvocationExpression.ArgumentList.Arguments.Select(Function(a) RefKind.None).ToImmutableArray(),
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\ImplementInterface\VisualBasicImplementInterfaceService.vb (1)
129g.Argument(DisposingName, RefKind.None, g.FalseLiteralExpression()))))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\InitializeParameter\InitializeParameterHelpers.vb (1)
64RefKind.None,
Microsoft.CodeAnalysis.VisualBasic.Features (11)
CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb (3)
144refKind:=RefKind.None, name:=eventHandlerName, 293modifiers:=Nothing, returnType:=returnType, refKind:=RefKind.None, 393refKind:=RefKind.None, name:=actualEventName + "Handler",
CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (1)
107Return parameter.RefKind <> RefKind.None
ExtractMethod\Extensions.vb (1)
149If parameter.RefKind <> RefKind.None Then
ExtractMethod\VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb (1)
84refKind:=RefKind.None,
GenerateType\VisualBasicGenerateTypeService.vb (1)
691refKind:=RefKind.None,
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (1)
155refKind:=RefKind.None,
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateParameterizedMemberService.vb (2)
37Return RefKind.None 132Me.InvocationExpression.ArgumentList.Arguments.Select(Function(a) RefKind.None).ToImmutableArray(),
src\roslyn\src\Analyzers\VisualBasic\CodeFixes\ImplementInterface\VisualBasicImplementInterfaceService.vb (1)
129g.Argument(DisposingName, RefKind.None, g.FalseLiteralExpression()))))
Microsoft.CodeAnalysis.VisualBasic.NetAnalyzers (2)
Microsoft.NetCore.Analyzers\Performance\BasicRecommendCaseInsensitiveStringComparisonFixer.vb (1)
115newArgumentNode = generator.Argument(RecommendCaseInsensitiveStringComparisonAnalyzer.StringParameterName, RefKind.None, argumentMemberAccessExpression.Expression)
Microsoft.NetCore.Analyzers\Runtime\BasicPreferStreamAsyncMemoryOverloads.Fixer.vb (1)
107Return generator.Argument(newName, RefKind.None, actualNode)
Microsoft.CodeAnalysis.VisualBasic.Workspaces (9)
CodeGeneration\VisualBasicSyntaxGenerator.vb (2)
804If refKind <> RefKind.None Then 1457Return Argument(name, RefKind.None, expression)
Simplification\VisualBasicSimplificationService.Expander.vb (1)
325parameter.RefKind <> RefKind.None Then
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb (3)
287Return parameter IsNot Nothing AndAlso parameter.RefKind <> RefKind.None 302Return method.Parameters(index).RefKind <> RefKind.None 307Return prop.Parameters(index).RefKind <> RefKind.None
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (1)
288parameter.RefKind <> RefKind.None Then
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)
602Return RefKind.None
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\InitializeParameter\InitializeParameterHelpers.vb (1)
64RefKind.None,
Microsoft.CodeAnalysis.Workspaces (20)
Editing\SyntaxGenerator.cs (2)
304RefKind refKind = RefKind.None) 2301=> Argument(name: null, RefKind.None, expression);
Rename\ConflictEngine\DeclarationConflictHelpers.cs (1)
113var refKind = distinguishRefKind ? parameter.RefKind : RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (2)
265=> CreateParameterSymbol(RefKind.None, type, name); 392refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (1)
79public RefKind RefKind => RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
Microsoft.Gen.Logging (3)
Parsing\Parser.cs (1)
548else if (paramSymbol.RefKind != RefKind.None)
Parsing\Parser.TagProvider.cs (2)
99&& method.Parameters[0].RefKind == RefKind.None 100&& method.Parameters[1].RefKind == RefKind.None
Microsoft.Interop.SourceGeneration (5)
Marshalling\AttributedMarshallingModelGeneratorResolver.cs (1)
455if (refKind == RefKind.None)
Marshalling\MarshallerHelpers.cs (2)
22ByValueContentsMarshalKind.Default => RefKind.None, 430RefKind.None => default,
TypePositionInfo.cs (2)
65public RefKind RefKind { get; init; } = RefKind.None; 67public bool IsByRef => RefKind != RefKind.None;
Roslyn.Diagnostics.Analyzers (40)
AbstractDoNotCopyValue.cs (21)
502if (!operation.IsRef && Acquire(operation) != RefKind.None) 575case RefKind.None: 1023if (Acquire(operation) != RefKind.None) 1097if (returnedValue is not null && Acquire(returnedValue) != RefKind.None) 1103else if (returnedValue is IParameterReferenceOperation { Parameter.RefKind: RefKind.None }) 1107else if (operation.GetRefKind(_context.OwningSymbol) == RefKind.None && Cache.IsNonCopyableType(returnedValue.Type)) 1128&& sourceRefKind != RefKind.None) 1265if (Acquire(resource) != RefKind.None) 1354(RefKind.None, _) => true, 1376=> RefKind.None, 1391_ => RefKind.None, 1395return RefKind.None; 1409_ => RefKind.None, 1413return RefKind.None; 1420return RefKind.None; 1435_ => RefKind.None, 1439return RefKind.None; 1442return RefKind.None; 1457(RefKind.None, RefKind.None) => RefKind.None,
ImportingConstructorShouldBeObsoleteCodeFixProvider.cs (1)
228var argument = generator.Argument("error", RefKind.None, generator.TrueLiteralExpression());
src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
185Name: "Dispose", MethodKind: MethodKind.Ordinary, ReturnsVoid: true, Parameters: [{ Type.SpecialType: SpecialType.System_Boolean, RefKind: RefKind.None }]
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)
236return containingMethod?.RefKind ?? RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (2)
125if (parameterRefKind == RefKind.None) 152if (parameterRefKind == RefKind.In && argumentRefKind == RefKind.None)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (1)
500if (symbol is IMethodSymbol method && method.Parameters.All(p => p.RefKind == RefKind.None))
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (2)
265=> CreateParameterSymbol(RefKind.None, type, name); 392refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConstructorSymbol.cs (1)
20refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationConversionSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationDestructorSymbol.cs (1)
16refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (1)
79public RefKind RefKind => RefKind.None;
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationOperatorSymbol.cs (1)
24refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
Roslyn.Diagnostics.CSharp.Analyzers (2)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ArgumentSyntaxExtensions.cs (1)
30_ => RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (1)
735return InferTypeInArgument(index, parameterizedSymbols, name, RefKind.None);
Roslyn.Diagnostics.VisualBasic.Analyzers (4)
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb (3)
287Return parameter IsNot Nothing AndAlso parameter.RefKind <> RefKind.None 302Return method.Parameters(index).RefKind <> RefKind.None 307Return prop.Parameters(index).RefKind <> RefKind.None
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SyntaxFacts\VisualBasicSyntaxFacts.vb (1)
602Return RefKind.None