1011 references to None
Aspire.Hosting.Azure.Provisioning.Generators (2)
AspireProvisioningProxyGenerator.cs (2)
1082if (parameter.RefKind != RefKind.None) 1854if (parameter.RefKind != RefKind.None ||
ConfigurationSchemaGenerator (1)
RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (1)
704else if (parameter.RefKind is not RefKind.None)
GenerateDocumentationAndConfigFiles (18)
src\30958ef190fa2467\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
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\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_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
ILLink.RoslynAnalyzer (8)
DataFlow\LocalDataFlowVisitor.cs (1)
350if (propertyRef.Property.RefKind is not RefKind.None)
DynamicallyAccessedMembersAnalyzer.cs (3)
186if (member is IFieldSymbol field && field.GetDynamicallyAccessedMemberTypes() != DynamicallyAccessedMemberTypes.None && !field.Type.IsTypeInterestingForDataflow(isByRef: field.RefKind is not RefKind.None)) 196if (parameter.GetDynamicallyAccessedMemberTypes() != DynamicallyAccessedMemberTypes.None && !parameter.Type.IsTypeInterestingForDataflow(isByRef: parameter.RefKind is not RefKind.None)) 327|| !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)
507if (p.RefKind != RefKind.None) 1465if ((symbol.RefKind == RefKind.None) == parameterInfo.IsRefOrOut)
Operations\ControlFlowGraphBuilder.cs (1)
4674return new SimpleAssignmentOperation(isRef: local.RefKind != RefKind.None,
Operations\OperationExtensions.cs (1)
327return 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\30958ef190fa2467\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
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\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_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
Microsoft.CodeAnalysis.AnalyzerUtilities (13)
src\2e2796bccd1466f6\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (1)
758&& (a.Parameter.RefKind == RefKind.None
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\a172c07bebba4cd8\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (1)
182Debug.Assert(parameter.RefKind != RefKind.None);
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\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))
Microsoft.CodeAnalysis.CodeStyle (15)
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
622if (symbol is IParameterSymbol { RefKind: not RefKind.None } || 623symbol is ILocalSymbol { RefKind: not RefKind.None } ||
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)
965methodSymbol.Parameters[0].RefKind == 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))
Microsoft.CodeAnalysis.CodeStyle.Fixes (21)
src\30958ef190fa2467\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, 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)
62var setAccessor = _isReadonly || _refKind != RefKind.None 117return _state.TypeToGenerateIn.TypeKind != TypeKind.Interface && _refKind != RefKind.None
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)
146document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None)); 160document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None)); 174document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None)); 259return 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_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
Microsoft.CodeAnalysis.CSharp (740)
Binder\Binder_AnonymousTypes.cs (1)
97RefKind.None,
Binder\Binder_Attributes.cs (2)
484BindArgumentExpression(diagnostics, argument.Expression, RefKind.None, allowArglist: false), 486refKind: RefKind.None);
Binder\Binder_Conversions.cs (6)
1447argumentRefKinds = argumentRefKinds.Add(RefKind.None); 1568if (method.Parameters is not [.., { RefKind: RefKind.None, Type: NamedTypeSymbol parameterType }] 3593{ RefKind: RefKind.None, ReturnsVoid: true } => method.ReturnsVoid, 3642: (sourceRefKind == RefKind.None) != (destinationRefKind == RefKind.None)) 3647if (sourceRefKind != RefKind.None)
Binder\Binder_Crefs.cs (4)
288refKind: RefKind.None, 319refKind: RefKind.None, 1001refKind: RefKind.None, 1018refKind: RefKind.None,
Binder\Binder_Expressions.cs (28)
491if (field is { IsStatic: false, RefKind: RefKind.None, ContainingSymbol: SourceMemberContainerTypeSymbol { PrimaryConstructor: { } primaryConstructor } } && 2043if (refKind != RefKind.None || type.IsRestrictedType()) 2125if (parameter.RefKind != RefKind.None) 2145(parameter.RefKind != RefKind.None || parameter.Type.IsRestrictedType()) && 2148if (parameter.RefKind != RefKind.None) 2162else if (primaryCtor is { ThisParameter.RefKind: not RefKind.None } && 2315if (localSymbol.RefKind == RefKind.None && type.IsRestrictedType(ignoreSpanLikeTypes: true)) 2621if (thisSymbol is not null && thisSymbol.ContainingSymbol != ContainingMemberOrLambda && thisSymbol.RefKind != RefKind.None) 3179RefKind refKind = origRefKind == RefKind.None || RefMustBeObeyed(isDelegateCreation, argumentSyntax) ? origRefKind : RefKind.None; 3192if (!hadError && isDelegateCreation && origRefKind != RefKind.None && result.Arguments.Count == 1) 3420if (refKind != RefKind.None) 3430result.RefKinds.Add(RefKind.None); 3481refKind == RefKind.None ? 3870refKind = RefKind.None; 3992if (argRefKind is RefKind.None or RefKind.In && parameter.RefKind == RefKind.RefReadOnlyParameter) 4016else if (argRefKind == RefKind.None && parameter.RefKind == RefKind.RefReadOnlyParameter) 8627extensionMethodArguments.RefKinds.Add(RefKind.None); 9896fieldSymbol.RefKind != RefKind.None) 10902if (refKind != RefKind.None) 11461original.Parameters[parameterOffset] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None } && 11462original.Parameters[parameterOffset + 1] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 11474getMethod.RefKind == RefKind.None; 11485original.Parameters[0] is { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None }; 12218if (returnsVoid && returnRefKind != RefKind.None) 12232returnRefKind == RefKind.None && 12234(parameterRefKinds.IsDefault || parameterRefKinds.All(refKind => refKind == RefKind.None)) && 12268parameterRefKinds.IsDefault ? RefKind.None : parameterRefKinds[i],
Binder\Binder_InterpolatedString.cs (2)
716refKindsBuilder.Add(RefKind.None); 717refKindsBuilder.Add(RefKind.None);
Binder\Binder_Invocation.cs (7)
301else if (analyzedArguments.RefKind(i) == RefKind.None) 308case RefKind.None: 1315Debug.Assert(analyzedArguments.RefKind(0) == RefKind.None); 1398CheckArgumentRefKind(RefKind.None, receiver, arg: 0, extensionParameter, invokedAsExtensionMethod: true, diagnostics); 1432if (receiver is BoundLocal { LocalSymbol: { RefKind: RefKind.None } local } && (local.IsUsing || local.IsForEach)) 1656argumentRefKindsBuilder.Add(RefKind.None); 1681argumentRefKindsBuilder.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); 3861(parameterCount == 0 || method.Parameters[0].RefKind is RefKind.None or RefKind.In); 3926(extensionParameter.Type.IsReferenceType && extensionParameter.RefKind == RefKind.None))) 4267if (parameterSymbol.RefKind != RefKind.None) 4298return localSymbol.RefKind != 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(GetAnonymousTypeFieldType(fieldValue, node, diagnostics)), 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); 2195if (delegateRefKind == RefKind.None) 3057refKind = RefKind.None; 3063var refKind = RefKind.None; 3092if (refKind != RefKind.None) 3104else if ((object)retType != null && (refKind != RefKind.None) != (sigRefKind != RefKind.None)) 3106var errorCode = refKind != RefKind.None 3215Debug.Assert(returnRefKind == RefKind.None); 3237if (returnRefKind != RefKind.None) 3545if (IsInAsyncMethod() && refKind != RefKind.None) 3554if ((refKind != RefKind.None) != (returnRefKind != RefKind.None) && expression.Kind != BoundKind.ThrowExpression) 3556var errorCode = refKind != RefKind.None 3561statement = new BoundReturnStatement(syntax, RefKind.None, expression, @checked: CheckOverflowAtRuntime) { WasCompilerGenerated = true }; 3694return bodyBinder.CreateBlockFromExpression(body, bodyBinder.GetDeclaredLocalsForScope(body), RefKind.None, expression, body, diagnostics); 3700if (refKind != RefKind.None)
Binder\Binder.QueryUnboundLambdaState.cs (1)
50public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }
Binder\Binder.ValueChecks.cs (68)
46Method is { RefKind: not RefKind.None, ReturnType: { } returnType } && 609if (indexerAccess.Indexer.RefKind != RefKind.None) 1332(localSymbol.RefKind == RefKind.None && !localSymbol.IsWritableVariable)) 1340if (localSymbol.RefKind == RefKind.None) 1372if (localSymbol.RefKind == RefKind.None) 1418else if (parameterSymbol.RefKind == RefKind.None && RequiresRefAssignableVariable(valueKind)) 1424Debug.Assert(parameterSymbol.RefKind != RefKind.None || !RequiresRefAssignableVariable(valueKind)); 1428if (parameterSymbol.RefKind == RefKind.None && 1432Debug.Assert(backingField.RefKind == RefKind.None); 1437Debug.Assert(backingField.RefKind == RefKind.None); 1539{ RefKind: RefKind.None } => SafeContext.CurrentMethod, 1574Debug.Assert(parameterSymbol.RefKind == RefKind.None || isRefScoped || refSafeToEscape.IsReturnOnly); 1624if ((fieldSymbol.RefKind == RefKind.None ? RequiresAssignableVariable(valueKind) : RequiresRefAssignableVariable(valueKind)) && 1636case RefKind.None: 1660case RefKind.None: 1684case RefKind.None: 1787if (fieldSymbol.RefKind != RefKind.None) 1811if (fieldSymbol.RefKind != RefKind.None) 1956if (RequiresVariable(valueKind) && methodSymbol.RefKind == RefKind.None) 2002propertySymbol.RefKind == RefKind.None) 2032var requiresSet = RequiresAssignableVariable(valueKind) && propertySymbol.RefKind == RefKind.None; 2102var requiresGet = !RequiresAssignmentOnly(valueKind) || propertySymbol.RefKind != RefKind.None; 2367(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2446result.ArgumentRefKindsOpt = [RefKind.None, .. methodInvocationInfo.ArgumentRefKindsOpt]; 2533var valid = effectiveRefKind != RefKind.None && isRefEscape ? 2595(param is { RefKind: not RefKind.None, Type: { } type } && type.IsRefLikeOrAllowsRefLikeType())) && 2726var refKind = parameter?.RefKind ?? RefKind.None; 2731if (refKind == RefKind.None && 2764return new EscapeArgument(parameter: null, receiver, RefKind.None); 2767var refKind = RefKind.None; 2794var refKind = argRefKindsOpt.IsDefault ? RefKind.None : argRefKindsOpt[argIndex]; 3007if (refKind != RefKind.None) 3027if (parameter.RefKind != RefKind.None && GetParameterRefEscapeLevel(parameter) is { } refEscapeLevel) 3091if (parameter.RefKind != RefKind.None && !parameter.IsThis) 3375if (_underlyingParameter.RefKind is not RefKind.None and var underlyingRefKind) 3382return RefKind.None; 3600Debug.Assert(field.RefKind == RefKind.None ? RequiresAssignableVariable(kind) : RequiresRefAssignableVariable(kind)); 3806if (methodSymbol.RefKind == RefKind.None) 3821if (methodSymbol.RefKind == RefKind.None) 3866if (methodSymbol.RefKind == RefKind.None) 3886Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None); 3894Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None); 3925conversion.Conversion.Method.RefKind == RefKind.None)); 3932unaryMethod.RefKind == RefKind.None)); 3939binaryMethod.RefKind == RefKind.None)); 3945logicalOperator.LogicalOperator.RefKind == RefKind.None)); 3952compoundMethod.RefKind == RefKind.None)); 3959incrementMethod.RefKind == RefKind.None)); 4096if (methodSymbol.RefKind == RefKind.None) 4115if (indexerSymbol.RefKind == RefKind.None) 4139if (indexerSymbol.RefKind == RefKind.None) 4163if (methodSymbol.RefKind == RefKind.None) 4187Debug.Assert(GetInlineArrayAccessEquivalentSignatureMethod(elementAccess, out _, out _).RefKind == RefKind.None); 4195Debug.Assert(equivalentSignatureMethod.RefKind != RefKind.None); 4210if (signature.RefKind == RefKind.None) 4227if (propertySymbol.RefKind == RefKind.None) 4267conversion.Conversion.Method.RefKind == RefKind.None); 4274unaryMethod.RefKind == RefKind.None)); 4281binaryMethod.RefKind == RefKind.None)); 4287logicalOperator.LogicalOperator.RefKind == RefKind.None)); 4294compoundMethod.RefKind == RefKind.None)); 4301incrementMethod.RefKind == RefKind.None)); 4947bool isSet = indexer.RefKind == RefKind.None; 5003bool isSet = property.RefKind == RefKind.None; 5716resultRefKind = RefKind.None; 5717parameterRefKind = RefKind.None; 5730resultRefKind = RefKind.None; 5791RefKind.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: 1221patternDisposeMethod.ParameterRefKinds.All(static refKind => refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter));
Binder\InMethodBinder.cs (2)
139if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType) 170if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType)
Binder\LockBinder.cs (1)
84if (enterScopeMethod is not { ReturnsVoid: false, RefKind: RefKind.None })
Binder\RefSafetyAnalysis.cs (4)
559Debug.Assert(localSymbol.RefKind == RefKind.None || 573if (localSymbol.RefKind != RefKind.None) 590ValidateEscape(expr, SafeContext.ReturnOnly, node.RefKind != RefKind.None, _diagnostics); 1320AddLocalScopes(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)
877else if (returnRefKind == RefKind.None) 2646if (refKind1 == RefKind.None && isAcceptableRefMismatch(refKind2, isInterpolatedStringHandlerConversion)) 2657else if (refKind2 == RefKind.None && isAcceptableRefMismatch(refKind1, isInterpolatedStringHandlerConversion)) 2692return isExtensionParameterOfStaticExtensionMember ? RefKind.None : parameter.RefKind; 2918Debug.Assert(refKind1 == RefKind.None || refKind1 == RefKind.Ref); 2919Debug.Assert(refKind2 == RefKind.None || refKind2 == RefKind.Ref); 2923if (refKind1 == RefKind.None) 3916hasSomeRefKinds |= member.ContainingType.ExtensionParameter.RefKind != RefKind.None; 3941RefKind argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 3946if (paramRefKind != RefKind.None) 3948refs = ArrayBuilder<RefKind>.GetInstance(arg, RefKind.None); 3980if (argRefKind == RefKind.None) 3982return RefKind.None; 3990else if (paramRefKind == RefKind.RefReadOnlyParameter && argRefKind is RefKind.None or RefKind.Ref or RefKind.In) 4003if ((options & Options.AllowRefOmittedArguments) != 0 && paramRefKind == RefKind.Ref && argRefKind == RefKind.None && !binder.InAttributeArgument) 4006return RefKind.None; 4094var argRefKind = hasAnyRefArg ? argumentRefKinds[arg] : RefKind.None; 4098if (paramRefKind != RefKind.None) 4577RefKind parameterRefKind = parameters.ParameterRefKinds.IsDefault ? RefKind.None : parameters.ParameterRefKinds[argumentPosition]; 4582if (argumentRefKind == RefKind.None) 4738Debug.Assert(argRefKind != RefKind.None); 4744if (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 (1)
63fieldSymbol.RefKind != RefKind.None ||
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; 847refKind == CodeAnalysis.RefKind.None && 1282refKind = CodeAnalysis.RefKind.None; 1609return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index]; 1643statements[0] is BoundReturnStatement { RefKind: Microsoft.CodeAnalysis.RefKind.None, ExpressionOpt: BoundExpression expr })
CodeGen\CodeGenerator_HasHome.cs (2)
114if (CodeGenerator.IsStackLocal(local, stackLocalsOpt) && localRefKind == RefKind.None) 280Debug.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\CodeGenerator.cs (1)
172var slotConstraints = _method.RefKind == RefKind.None
CodeGen\EmitAddress.cs (5)
37Debug.Assert(((BoundDup)expression).RefKind != RefKind.None, "taking address of a stack value?"); 301if (local.RefKind != RefKind.None) 523if (parameterSymbol.RefKind == RefKind.None) 598field.RefKind == RefKind.None ? 602_builder.EmitOpCode(field.RefKind == RefKind.None ? ILOpCode.Ldflda : ILOpCode.Ldfld);
CodeGen\EmitExpression.cs (36)
707RefKind refKind = expression.ArgumentRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : expression.ArgumentRefKindsOpt[i]; 716case RefKind.None: 727Debug.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"); 738case RefKind.None: 785if (expression.RefKind == RefKind.None) 957Debug.Assert(parameters.All(p => p.RefKind == RefKind.None) || !argRefKindsOpt.IsDefault, "there are nontrivial parameters, so we must have argRefKinds"); 1009argRefKind = RefKind.None; 1137if (!field.IsVolatile && !field.IsStatic && fieldAccess.ReceiverOpt.Type.IsVerifierValue() && field.RefKind == RefKind.None) 1149if (field.RefKind != RefKind.None) 1293return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 1297return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 1306if (field.IsStatic || field.RefKind != RefKind.None) 1397bool isRefLocal = local.LocalSymbol.RefKind != RefKind.None; 1436if (used || parameter.ParameterSymbol.RefKind != RefKind.None) // unused value parameter has no side-effects 1441if (parameter.ParameterSymbol.RefKind != RefKind.None) 2260return ((BoundLocal)receiver).LocalSymbol.RefKind != RefKind.None; 2263return ((BoundParameter)receiver).ParameterSymbol.RefKind != RefKind.None; 2266return ((BoundCall)receiver).Method.RefKind != RefKind.None; 2269return ((BoundFunctionPointerInvocation)receiver).FunctionPointer.Signature.RefKind != RefKind.None; 2272return ((BoundDup)receiver).RefKind != RefKind.None; 2684if (System.Linq.ImmutableArrayExtensions.All(ctor.Parameters, p => p.RefKind == RefKind.None) && 2815return ((BoundParameter)left).ParameterSymbol.RefKind == RefKind.None; 2820return ((BoundLocal)left).LocalSymbol.RefKind == RefKind.None; 2840if (left.FieldSymbol.RefKind != RefKind.None && 2858if (left.ParameterSymbol.RefKind != RefKind.None && 2890if (left.LocalSymbol.RefKind != RefKind.None && !assignmentOperator.IsRef) 2989Debug.Assert(left.Method.RefKind != RefKind.None); 3000Debug.Assert(left.FunctionPointer.Signature.RefKind != RefKind.None); 3145if (local.LocalSymbol.RefKind != RefKind.None && !assignment.IsRef) 3178Debug.Assert(((BoundDup)expression).RefKind != RefKind.None); 3201Debug.Assert(((BoundCall)expression).Method.RefKind != RefKind.None); 3206Debug.Assert(((BoundFunctionPointerInvocation)expression).FunctionPointer.Signature.RefKind != RefKind.None); 3350if (field.RefKind != RefKind.None && !refAssign) 3365if (parameter.ParameterSymbol.RefKind != RefKind.None && !refAssign) 4162if (useKind == UseKind.UsedAsValue && method.RefKind != RefKind.None) 4168Debug.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) 1232if (unwrappedSequence is BoundLocal { LocalSymbol: { RefKind: not RefKind.None } localSymbol }) 1285ExprContext context = (argRefKind == RefKind.None) ? ExprContext.Value : ExprContext.Address; 1311RefKind refKind = argRefKindsOpt.IsDefaultOrEmpty ? RefKind.None : argRefKindsOpt[i]; 1439if (localSym.RefKind == RefKind.None) 1893Debug.Assert(local.RefKind == RefKind.None, "cannot take a ref of a ref"); 1954return top.Item2 == (local.RefKind == RefKind.None ? ExprContext.Value : ExprContext.Address) && 2229var isIndirectLocalStore = left.LocalSymbol.RefKind != RefKind.None && !node.IsRef; 2497get { return RefKind.None; }
Compilation\CSharpCompilation.cs (2)
2329if (method.RefKind != RefKind.None) 4428fields.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)
1293VisitRvalue(node.InitializerOpt, isKnownToBeAnLvalue: node.LocalSymbol.RefKind != RefKind.None); 1296if (node.LocalSymbol.RefKind != RefKind.None) 1532VisitRvalue(arguments[i], isKnownToBeAnLvalue: refKind != RefKind.None); 1552case RefKind.None: 1576return refKindsOpt.IsDefault || refKindsOpt.Length <= index ? RefKind.None : refKindsOpt[index]; 2033VisitRvalue(node.ExpressionOpt, isKnownToBeAnLvalue: node.RefKind != RefKind.None); 2036if (node.RefKind != RefKind.None) 2147if (property.RefKind == RefKind.None) 2202if (property.RefKind == RefKind.None) 2221if (property.RefKind == RefKind.None) 2838if (property.RefKind == RefKind.None) 3766property.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) 2572if (refKind != RefKind.None && ((object)method == null || method.IsExtern) && arg.Type is TypeSymbol type) 2764NoteWrite(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 (15)
2586return AreParameterAnnotationsCompatible(RefKind.None, overriddenType, overriddenAnnotations, overridingType, overridingAnnotations, forRef: true) && 2590if (refKind is RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter) 3165if (node.RefKind == RefKind.None && 3174if (node.RefKind == RefKind.None) 7110if (receiverRefKind == RefKind.None) 7115var builder = ArrayBuilder<RefKind>.GetInstance(argumentCount + 1, fillWithValue: RefKind.None); 7130return extensionParameter.RefKind == RefKind.Ref ? RefKind.Ref : RefKind.None; 7961refKindsBuilder.AddMany(RefKind.None, elements.Length); 8234case RefKind.None: 8295case RefKind.None: 8431case RefKind.None: 8704if (refKind == RefKind.None) 11470case BoundLocal { LocalSymbol.RefKind: RefKind.None }: 11471case BoundParameter { ParameterSymbol: { RefKind: RefKind.None } parameter } when 13752TypeWithAnnotations 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)
70if (thisParameter is { Type.IsValueType: true, RefKind: not RefKind.None })
Lowering\ClosureConversion\ClosureConversion.cs (2)
577new BoundReturnStatement(syntax, RefKind.None, null, @checked: false)); 937refkindsBuilder.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) 585if (_inExpressionLambda && property.RefKind != RefKind.None) 627if (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_AssignmentOperator.cs (4)
239Debug.Assert(!isRef || rewrittenLeft.GetRefKind() != RefKind.None); 341(arguments.Length != 0 || !IsSafeForReordering(rewrittenRight, RefKind.None))) 381if (!IsSafeForReordering(rewrittenRight, RefKind.None)) 383BoundLocal capturedRight = _factory.StoreToTemp(rewrittenRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter_Call.cs (30)
303if (thisRefKind != RefKind.None 320if (argumentRefKindsOpt.IsDefault && thisRefKind != RefKind.None) 324Debug.Assert(argumentRefKindsOpt.All(static refKind => refKind == RefKind.None)); 577return kind != RefKind.None && current.GetRefKind() == RefKind.None; 582return kind != RefKind.None && 583(current.GetRefKind() == RefKind.None || 718refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None; 725refKind = RefKind.None; 732refKind = RefKind.None; 738if (refKind == RefKind.None && 1014bool isReceiverTakenByValue = receiverRefKind == RefKind.None; 1019return RefKind.None; 1033return RefKind.None; 1047return RefKind.None; 1054case RefKind.None: 1140receiverTemp = _factory.Local(_factory.SynthesizedLocal(receiverType, refKind: RefKind.None)); 1256ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 1332var currentArgRefKind = argumentRefKindsOpt.IsDefault ? RefKind.None : argumentRefKindsOpt[i]; 1363refKindsBuilder = ArrayBuilder<RefKind>.GetInstance(parameters.Length, fillWithValue: RefKind.None); 1379Debug.Assert(initialArgRefKind is RefKind.None or RefKind.In or RefKind.Ref); 1380return initialArgRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn; 1382else if (paramRefKind == RefKind.Ref && initialArgRefKind == RefKind.None) 1458if (refKind != RefKind.None) 1541Debug.Assert(argRefKind == RefKind.None); 1557arg.rewriter.StoreArgumentToTempIfNecessary(arg.forceLambdaSpilling, arg.storesToTemps, element, RefKind.None, RefKind.None), 1586? (argRefKind == RefKind.None ? RefKind.In : RefKindExtensions.StrictIn) 1818if (argRefKind != RefKind.None || paramRefKind != RefKind.Ref) 1833Debug.Assert(localRefKind == RefKind.None);
Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (15)
234BoundLocal binaryResult = _factory.StoreToTemp(opFinal, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None); 259return symbol.IsExtensionBlockMember() && !symbol.IsStatic && symbol.ContainingType.ExtensionParameter is { RefKind: RefKind.None, Type.IsReferenceType: false }; 322refKind = RefKind.None; 327refKind = variableRepresentsLocation ? RefKind.Ref : RefKind.None; 521ArrayBuilder<RefKind> refKinds = ArrayBuilder<RefKind>.GetInstance(parameters.Length, RefKind.None); 594Debug.Assert(implicitIndexerAccess.IndexerOrSliceAccess.GetRefKind() == RefKind.None); 698var temp = _factory.StoreToTemp(VisitExpression(arguments[i]), out assignmentToTemp, indexerAccess.ArgumentRefKindsOpt.RefKinds(i) != RefKind.None ? RefKind.Ref : RefKind.None); 769if (propertyAccess.PropertySymbol.RefKind == RefKind.None) 784if (indexerAccess.GetRefKind() == RefKind.None) 797if (implicitIndexerAccess.GetRefKind() == RefKind.None) 871Debug.Assert(((BoundCall)originalLHS).Method.RefKind != RefKind.None); 875Debug.Assert(((BoundFunctionPointerInvocation)originalLHS).FunctionPointer.Signature.RefKind != RefKind.None); 1027((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None || 1031return 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)
121if (isLeftOfAssignment && indexer.RefKind == RefKind.None) 569RefKind refKind = receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref; 673if (isLeftOfAssignment && indexerAccess.GetRefKind() == RefKind.None) 912RefKind refKind = receiver.Type.IsReferenceType ? RefKind.None : RefKind.Ref;
Lowering\LocalRewriter\LocalRewriter_NullCoalescingAssignmentOperator.cs (1)
48BoundLocal rightResult = _factory.StoreToTemp(loweredRight, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter_NullCoalescingOperator.cs (1)
146if (unwrappedRight is { ConstantValueOpt: not null } or BoundLocal { LocalSymbol.IsRef: false } or BoundParameter { ParameterSymbol.RefKind: RefKind.None } &&
Lowering\LocalRewriter\LocalRewriter_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); 643elementArg.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_UnaryOperator.cs (3)
638return ((BoundLocal)expression).LocalSymbol.RefKind != RefKind.None; 642return ((BoundParameter)expression).ParameterSymbol.RefKind != RefKind.None; 671BoundLocal incrementResult = _factory.StoreToTemp(newValue, out BoundAssignmentOperator assignmentToTemp, refKind: RefKind.None);
Lowering\LocalRewriter\LocalRewriter.cs (3)
1099return ((BoundCall)expr).Method.RefKind != RefKind.None; 1102return ((BoundPropertyAccess)expr).PropertySymbol.RefKind != RefKind.None; 1105return ((BoundIndexerAccess)expr).Indexer.RefKind != RefKind.None;
Lowering\LocalRewriter\LocalRewriter.PatternLocalRewriter.cs (1)
555&& loweredInput.GetRefKind() == 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)
270if (leftLocal.LocalSymbol.RefKind != RefKind.None &&
Lowering\SpillSequenceSpiller.cs (26)
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 }, 550Left: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } referenceTypeClone }, 554Value: BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: RefKind.None } } referenceTypeReceiver 575if (valueTypeReceiverLocal is { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } 576&& originalReceiver is BoundLocal { LocalSymbol: { SynthesizedKind: SynthesizedLocalKind.LoweringTemp, RefKind: not RefKind.None } } originalReceiverLocal 682var refKind = refKinds.IsDefault ? RefKind.None : refKinds[i]; 1032expression = Spill(builder, expression, RefKind.None); 1104Debug.Assert(refKind == RefKind.None || !receiver.Type.IsReferenceType); 1119if (refKind != RefKind.None && 1157var result = RefKind.None; 1370if (receiver.Type.IsReferenceType || receiver.Type.IsValueType || receiverRefKind == RefKind.None) 1373receiver = Spill(receiverBuilder, receiver, RefKind.None); 1390var clone = _F.SynthesizedLocal(receiver.Type, _F.Syntax, refKind: RefKind.None, kind: SynthesizedLocalKind.Spill);
Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (6)
98Debug.Assert(local.RefKind != RefKind.None); 222case ParameterSymbol { RefKind: RefKind.None }: 223case LocalSymbol { RefKind: RefKind.None }: 224case FieldSymbol { RefKind: RefKind.None }: 232(variable is LocalSymbol { RefKind: not RefKind.None } refLocal && !canRefLocalBeHoisted(refLocal))) 270Debug.Assert(parameter.IsThis || parameter.RefKind == RefKind.None);
Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (1)
317if (local.RefKind != RefKind.None)
Lowering\StateMachineRewriter\RefInitializationHoister.cs (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)
175if (local.RefKind != RefKind.None) 183Debug.Assert(local.RefKind == RefKind.None);
Lowering\StateMachineRewriter\SynthesizedStateMachineProperty.cs (1)
44get { return RefKind.None; }
Lowering\SyntheticBoundNodeFactory.cs (9)
580Debug.Assert(CurrentFunction.RefKind == RefKind.None); 585return new BoundReturnStatement(Syntax, CurrentFunction.RefKind != RefKind.None ? RefKind.Ref : RefKind.None, expression, @checked: false) { WasCompilerGenerated = true }; 605RefKind refKind = RefKind.None, 645return SynthesizedParameterSymbol.Create(container, TypeWithAnnotations.Create(type), ordinal, RefKind.None, name); 1673RefKind refKind = RefKind.None, 1704refKind = RefKind.None; 1708case RefKind.None: 1740isRef: 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)
45public 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)
356if (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)
349RefKind.None; 687if (RefKind != RefKind.None &&
Symbols\Metadata\PE\PEMethodSymbol.cs (2)
1161case RefKind.None: 1192case 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 (6)
2197RefKind: RefKind.None, 2199Parameters: [{ RefKind: RefKind.In or RefKind.None }] 2398return ctor is { DeclaredAccessibility: Accessibility.Public, ParameterCount: 1, Parameters: [{ RefKind: RefKind.In or RefKind.None }] }; 2482RefKind: RefKind.None, 2667RefKind: RefKind.None, 2856RefKind: RefKind.None,
Symbols\ParameterSignature.cs (2)
49if (refKind != RefKind.None) 51refs = ArrayBuilder<RefKind>.GetInstance(parm, RefKind.None);
Symbols\ParameterSymbol.cs (1)
168((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)
320Debug.Assert(_refKind == RefKind.None
Symbols\Source\ParameterHelpers.cs (6)
894else if (refKind != RefKind.None && 1135var refKind = RefKind.None; 1147if (refKind == RefKind.None) 1154if (refKind == RefKind.None) 1161if (refKind == RefKind.None) 1190scope = (refKind == RefKind.None) ? ScopedKind.ScopedValue : ScopedKind.ScopedRef;
Symbols\Source\SourceAssemblySymbol.cs (1)
2765else if (field.RefKind != RefKind.None)
Symbols\Source\SourceComplexParameterSymbol.cs (2)
905return RefKind != RefKind.None || (HasParamsModifier && Type.IsRefLikeOrAllowsRefLikeType()); 1804Debug.Assert(refKind != RefKind.None || _refCustomModifiers.IsEmpty);
Symbols\Source\SourceConstructorSymbol.cs (1)
112methodKind, RefKind.None, declarationModifiers, returnsVoid: true, returnsVoidIsSet: true, hasAnyBody: hasAnyBody,
Symbols\Source\SourceDelegateMethodSymbol.cs (8)
223: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 226SynthesizedParameterSymbol.Create(this, objectType, 0, RefKind.None, "object"), 227SynthesizedParameterSymbol.Create(this, intPtrType, 1, RefKind.None, "method"))); 363: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 373parameters.Add(SynthesizedParameterSymbol.Create(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback"))); 374parameters.Add(SynthesizedParameterSymbol.Create(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object"))); 412if (p.RefKind != RefKind.None) 419parameters.Add(SynthesizedParameterSymbol.Create(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));
Symbols\Source\SourceDestructorSymbol.cs (1)
69MethodKind.Destructor, RefKind.None, declarationModifiers, returnsVoid: true, returnsVoidIsSet: true,
Symbols\Source\SourceEnumConstantSymbol.cs (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_ImplementationChecks.cs (1)
1460else if (parameters.Any(p => p.RefKind == RefKind.None && p.Type.IsRefLikeOrAllowsRefLikeType()))
Symbols\Source\SourceMemberContainerSymbol.cs (14)
4665if (methodParam.RefKind != RefKind.None) 4688methodParams[0].RefKind == RefKind.None && 5184RefKind.None, 5230RefKind.None 5232RefKind.None, 5283RefKind.None)), 5284RefKind.None, 5339RefKind.None, 5418RefKind.None, 5513RefKind.None, 5544RefKind.None, 5610RefKind.None 5612RefKind.None, 5820var modifiers = SourceMemberFieldSymbol.MakeModifiers(this, fieldSyntax.Declaration.Variables[0].Identifier, fieldSyntax.Modifiers, isRefField: refKind != RefKind.None, diagnostics, out modifierErrors);
Symbols\Source\SourceMemberFieldSymbol.cs (6)
496RefKind refKind = RefKind.None; 534Debug.Assert(refKind is RefKind.None or RefKind.Ref or RefKind.RefReadOnly); 536if (refKind != RefKind.None) 553Debug.Assert(refKindToAssert == RefKind.None); // Otherwise we might need to report an error 584var initializerOpt = executableBinder.BindInferredVariableInitializer(diagnostics, RefKind.None, syntaxNode, declarator); 613if (refKind != RefKind.None)
Symbols\Source\SourceMethodSymbol.cs (1)
70if (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)
252_lazyRefCustomModifiers = _refKind != RefKind.None ? overriddenOrImplementedProperty.RefCustomModifiers : ImmutableArray<CustomModifier>.Empty; 889if (RefKind != RefKind.None && IsRequired) 913if (this.RefKind != RefKind.None) 960if (_refKind != RefKind.None) 994else 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)
34public 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)
42RefKind.None,
Symbols\Synthesized\Records\SynthesizedRecordEqualityOperator.cs (1)
45if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None &&
Symbols\Synthesized\Records\SynthesizedRecordEqualityOperatorBase.cs (2)
75ordinal: 0, RefKind.None, "left", Locations), 78ordinal: 1, RefKind.None, "right", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordEquals.cs (1)
41ordinal: 0, RefKind.None, "other", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordObjEquals.cs (1)
37ordinal: 0, RefKind.None, "obj", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordOrdinaryMethod.cs (1)
17MethodKind.Ordinary, RefKind.None, declarationModifiers, returnsVoid: false, returnsVoidIsSet: false,
Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (1)
98ordinal: 0, RefKind.None, "builder", Locations)));
Symbols\Synthesized\Records\SynthesizedRecordPropertySymbol.cs (1)
41RefKind.None,
Symbols\Synthesized\RefKindVector.cs (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\SynthesizedEmbeddedAttributePropertySymbol.cs (2)
27public override RefKind RefKind => RefKind.None; 90public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\SynthesizedEmbeddedExtensionMarkerNameAttributeSymbol.cs (1)
41return [SynthesizedParameterSymbol.Create(ctor, TypeWithAnnotations.Create(systemStringType), ordinal: 0, RefKind.None, name: "name")];
Symbols\Synthesized\SynthesizedEmbeddedMemorySafetyRulesAttributeSymbol.cs (1)
66refKind: RefKind.None,
Symbols\Synthesized\SynthesizedEmbeddedNativeIntegerAttributeSymbol.cs (1)
53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, boolArrayType, 0, RefKind.None)),
Symbols\Synthesized\SynthesizedEmbeddedNullableAttributeSymbol.cs (2)
53m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, annotatedByteType, 0, RefKind.None)), 57m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, byteArrayType, 0, RefKind.None)),
Symbols\Synthesized\SynthesizedEmbeddedNullableContextAttributeSymbol.cs (1)
41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemByteType), 0, RefKind.None)),
Symbols\Synthesized\SynthesizedEmbeddedNullablePublicOnlyAttributeSymbol.cs (1)
41m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(systemBooleanType), 0, RefKind.None)),
Symbols\Synthesized\SynthesizedEmbeddedRefSafetyRulesAttributeSymbol.cs (1)
39m => ImmutableArray.Create(SynthesizedParameterSymbol.Create(m, TypeWithAnnotations.Create(int32Type), 0, RefKind.None)),
Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (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)
31public 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)
19SynthesizedParameterSymbol.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)
38public override RefKind RefKind => RefKind.None;
Symbols\Synthesized\SynthesizedLocal.cs (1)
41RefKind 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)
36RefKind.None,
Symbols\Tuples\TupleErrorFieldSymbol.cs (1)
159public override RefKind RefKind => RefKind.None;
Symbols\TypeSymbol.cs (2)
2029RefKind interfaceMemberRefKind = RefKind.None; 2589return 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)
284refKind = RefKind.None; 325refKind = 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: 3680=> 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)
592? (TArgumentSyntax)_generator.Argument(parameterName, RefKind.None, newArgumentExpression)
ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)
137setMethod.Parameters is [{ RefKind: RefKind.None } parameter] &&
src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (2)
622if (symbol is IParameterSymbol { RefKind: not RefKind.None } || 623symbol is ILocalSymbol { RefKind: not RefKind.None } ||
src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)
965methodSymbol.Parameters[0].RefKind == 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)
62var setAccessor = _isReadonly || _refKind != RefKind.None 117return _state.TypeToGenerateIn.TypeKind != TypeKind.Interface && _refKind != RefKind.None
src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (4)
146document, state, generateProperty: false, isReadonly: false, isConstant: true, refKind: RefKind.None)); 160document, state, generateProperty: false, isReadonly: true, isConstant: false, refKind: RefKind.None)); 174document, state, generateProperty: false, isReadonly: false, isConstant: false, refKind: RefKind.None)); 259return 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.NetAnalyzers (20)
Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\CancellationTokenParametersMustComeLast.cs (1)
124while (last >= 0 && methodSymbol.Parameters[last].RefKind != RefKind.None)
Microsoft.CodeQuality.Analyzers\Maintainability\DoNotIgnoreMethodResults.cs (1)
338method.Parameters[1].RefKind != RefKind.None;
Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshalling.cs (1)
170if (param.RefKind != RefKind.None)
Microsoft.NetCore.Analyzers\InteropServices\DoNotUseOutAttributeStringPInvokeParameters.cs (1)
63&& parameter.RefKind == RefKind.None
Microsoft.NetCore.Analyzers\Performance\PreferReadOnlySpanOverSpan.cs (1)
442if (parameter.RefKind is RefKind.None &&
Microsoft.NetCore.Analyzers\Performance\RecommendCaseInsensitiveStringComparison.Fixer.cs (1)
226generator.Argument(name: RCISCAnalyzer.StringComparisonParameterName, RefKind.None, stringComparisonEnumValueAccess) :
Microsoft.NetCore.Analyzers\Performance\UseStringContainsCharOverloadWithSingleCharacters.Fixer.cs (1)
48newExpression = editor.Generator.Argument(argumentName, RefKind.None, newExpression);
Microsoft.NetCore.Analyzers\Runtime\ForwardCancellationTokenToInvocations.Fixer.cs (1)
165cancellationTokenArgument = generator.Argument(fix.ParameterName, RefKind.None, identifier);
Microsoft.NetCore.Analyzers\Runtime\PreferReadOnlySpanPropertiesOverReadOnlyArrayFieldsAnalyzer.cs (1)
251method.Parameters is [{ RefKind: RefKind.None, Type.SpecialType: SpecialType.System_RuntimeFieldHandle }] &&
Microsoft.NetCore.Analyzers\Runtime\UseSpanBasedStringConcat.Fixer.cs (1)
166var renamedArgumentSyntax = generator.Argument(AsSpanStartParameterName, RefKind.None, startIndexSyntax);
src\40daf5e1cab76dff\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (1)
757&& (a.Parameter.RefKind == RefKind.None
src\9382845807600969\AbstractLocationDataFlowOperationVisitor.cs (1)
43if (parameter.RefKind == RefKind.None)
src\9382845807600969\AnalysisEntityDataFlowOperationVisitor.cs (1)
313if (parameter.RefKind != RefKind.None)
src\afc74d572e54ec72\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (1)
179Debug.Assert(parameter.RefKind != RefKind.None);
src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IEnumerableOfIMethodSymbolExtensions.cs (2)
57if (!trailingOnly && candidateMethod.Parameters.First().Type.Equals(expectedParameterType) && candidateMethod.Parameters[0].RefKind == RefKind.None) 66if (!lastParameter.Type.Equals(expectedParameterType) || lastParameter.RefKind != RefKind.None)
src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (1)
246parameter.RefKind == RefKind.None;
src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)
1103return containingMethod?.RefKind ?? RefKind.None;
src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AddressSharedEntitiesProvider.cs (1)
44if (parameter.RefKind != RefKind.None &&
src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (1)
593if (parameter.RefKind == RefKind.None || DataFlowAnalysisContext.InterproceduralAnalysisData == null)
Microsoft.CodeAnalysis.ResxSourceGenerator (7)
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
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))
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.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\30958ef190fa2467\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == 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\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_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: RefKind.None,
Microsoft.Extensions.Configuration.Binder.SourceGeneration (2)
ConfigurationBindingGenerator.Parser.cs (1)
796else if (parameter.RefKind is not RefKind.None)
Emitter\CoreBindingHelpers.cs (1)
344RefKind.None => name,
Microsoft.Extensions.Options.SourceGeneration (1)
Parser.cs (1)
308|| method.Parameters.Any(p => p.RefKind != RefKind.None)
Microsoft.Gen.Logging (3)
Parsing\Parser.cs (1)
617else 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 (7)
MarshalAsParser.cs (1)
265&& info.RefKind is RefKind.None or RefKind.In or RefKind.Ref;
Marshalling\AttributedMarshallingModelGeneratorResolver.cs (1)
415if (refKind == RefKind.None)
Marshalling\MarshallerHelpers.cs (2)
16ByValueContentsMarshalKind.Default => RefKind.None, 415RefKind.None => string.Empty,
SignatureContext.cs (1)
162RefKind = nativeIndex == TypePositionInfo.ReturnIndex ? RefKind.None : RefKind.Out,
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\30958ef190fa2467\SyntaxGeneratorInternal.cs (2)
114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue }; 145=> TypeExpression(typeSymbol, RefKind.None);
src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (2)
78: (rk1 == RefKind.None) == (rk2 == RefKind.None);
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\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_CreateEqualsMethod.cs (1)
67refKind: RefKind.None,
src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (1)
320refKind: 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);
System.Text.Json.SourceGeneration (2)
JsonSourceGenerator.Emitter.cs (1)
1458: $"new global::System.Type[] {{{string.Join(", ", parameters.Select(p => $"typeof({p.ParameterType.FullyQualifiedName}){(p.RefKind is RefKind.None ? "" : ".MakeByRefType()")}"))}}}";
JsonSourceGenerator.Parser.cs (1)
1629member.Parameters[0].RefKind is not RefKind.None)
System.Windows.Forms.Analyzers (1)
System\Windows\Forms\Analyzers\Designer\DesignerTypeFacts.cs (1)
96&& method.Parameters[0].RefKind == RefKind.None