Parameter

Generated\Operations.Generated.cs (1)

7964public IParameterSymbol? Parameter { get; }

AppHostAnalyzer.cs (1)

128if (SymbolEqualityComparer.Default.Equals(modelNameParameter, argument.Parameter))

RuntimeSource\Configuration.Binder\Parser\ConfigurationBinder.cs (2)

82if (instanceArg.Parameter?.Type.SpecialType is not SpecialType.System_Object) 124if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

500if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

DataFlow\LocalDataFlowVisitor.cs (2)

952if (argument?.Parameter == null) 955var parameter = argument.Parameter;

IOperationExtensions.cs (1)

138switch (argumentOperation.Parameter?.RefKind)

MiddlewareAnalyzer.cs (1)

36SymbolEqualityComparer.Default.Equals(invocation.Arguments[0].Parameter?.Type, _context.StartupSymbols.IApplicationBuilder))

ServicesAnalyzer.cs (1)

31SymbolEqualityComparer.Default.Equals(invocation.Arguments[0].Parameter?.Type, _context.StartupSymbols.IServiceCollection))

Kestrel\ListenOnIPv6AnyAnalyzer.cs (1)

48if (!IsIPAddressType(addressArgument?.Parameter))

RenderTreeBuilder\RenderTreeBuilderAnalyzer.cs (1)

41if (argument.Parameter?.Ordinal == SequenceParameterOrdinal)

RouteHandlers\DetectAmbiguousRoutes.cs (1)

275if (SymbolEqualityComparer.Default.Equals(arguments[i].Parameter, parameter))

RouteHandlers\RouteHandlerAnalyzer.cs (3)

80if (argument.Parameter?.Ordinal == DelegateParameterOrdinal) 178if (argument.Parameter?.Ordinal == 1) 227var builderArgument = operation.Arguments.SingleOrDefault(a => a.Parameter?.Ordinal == 0);

StaticRouteHandlerModel\InvocationOperationExtensions.cs (2)

33routeHandlerParameter is { Parameter.Type: {} delegateType } && 61if (argument.Parameter?.Ordinal == routeHandlerArgumentOrdinal)

ActualApiResponseMetadataFactory.cs (1)

198var parameter = argument.Parameter;

Operations\ControlFlowGraphBuilder.cs (1)

6858Debug.Assert(outParameterArgument is { Parameter: { RefKind: RefKind.Out, Type.SpecialType: SpecialType.System_Boolean } });

FixAnalyzers\FixerWithFixAllAnalyzer.cs (1)

266if (SymbolEqualityComparer.Default.Equals(argument.Parameter, param))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer_IdRangeAndCategoryValidation.cs (1)

149if (argument.Parameter?.Name.Equals(CategoryParameterName, StringComparison.Ordinal) == true)

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (11)

572firstParamArgument.Parameter?.Type.SpecialType == SpecialType.System_String && 600invocation.Arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String && 625IArgumentOperation? titleArgument = creationArguments.FirstOrDefault(a => a.Parameter?.Name.Equals("title", StringComparison.OrdinalIgnoreCase) == true); 628if (titleArgument.Parameter?.Type.SpecialType == SpecialType.System_String) 727var messageArgument = creationArguments.FirstOrDefault(a => a.Parameter?.Name.Equals("messageFormat", StringComparison.OrdinalIgnoreCase) == true); 774IArgumentOperation? descriptionArgument = creationArguments.FirstOrDefault(a => a.Parameter?.Name.Equals("description", StringComparison.OrdinalIgnoreCase) == true); 817SymbolEqualityComparer.Default.Equals(argument.Parameter?.Type, localizableStringType)) 1037if (argument.Parameter?.Name.Equals(HelpLinkUriParameterName, StringComparison.OrdinalIgnoreCase) == true) 1067a => a.Parameter?.Name.Equals(CustomTagsParameterName, StringComparison.OrdinalIgnoreCase) == true); 1117switch (argument.Parameter?.Name) 1202if (argument.Parameter?.Name.Equals(DiagnosticIdParameterName, StringComparison.OrdinalIgnoreCase) == true)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

500if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

src\2e2796bccd1466f6\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (15)

293.Where(s => s.Parameter != null && this.GetCachedAbstractValue(s).Kind == TaintedDataAbstractValueKind.Tainted) 294.Select(s => s.Parameter!.Name); 320IArgumentOperation? argumentOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == taintedTarget); 321if (argumentOperation?.Parameter != null) 324this.CacheAbstractValue(argumentOperation, TaintedDataAbstractValue.CreateTainted(argumentOperation.Parameter, argumentOperation.Syntax, method)); 354: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenTaintedTarget); 359: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == ifTaintedParameter); 399IArgumentOperation? thenSanitizedTargetOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenSanitizedTarget); 690taintedArgument.Parameter == null) 697&& taintedArgument.Parameter.Type.SpecialType == SpecialType.System_String) 702&& sinkParameters.Contains(taintedArgument.Parameter.MetadataName)) 757&& a.Parameter != null 758&& (a.Parameter.RefKind == RefKind.None 759|| a.Parameter.RefKind == RefKind.Ref 760|| a.Parameter.RefKind == RefKind.In));

src\66dd3055a1c91c38\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (4)

289Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 307if ((operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) && 319else if (operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) 321if (operation.Parameter.RefKind == RefKind.Ref)

src\683181b2796de991\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

348if (isNullCheckValidationMethod || HasAnyNullValidationAttribute(argument.Parameter))

src\a03b2aad21e28a8a\PropertySetAnalysis.PropertySetDataFlowOperationVisitor.cs (2)

534if (argumentTypeSymbol == null || argumentOperation.Parameter == null) 543argumentOperation.Parameter.MetadataName,

src\a172c07bebba4cd8\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (7)

190Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 341operation.Parameter?.RefKind == RefKind.Out && 368if (operation.Parameter?.RefKind is RefKind.Out or RefKind.Ref) 378if (operation.Parameter == null || 379operation.Parameter.RefKind == RefKind.Out) 388DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type), 391IsDisposableCreationSpecialCase(invocation.TargetMethod) && DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type),

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

500if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\CopyAnalysis\CopyAnalysis.CopyDataFlowOperationVisitor.cs (1)

319Debug.Assert(operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out);

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysisHelper.cs (1)

160operation.Parent is IArgumentOperation argument && argument.Parameter?.RefKind == RefKind.Out) &&

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\HardcodedBytesSources.cs (4)

50arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 63arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 78arguments[0].Parameter?.Type is IArrayTypeSymbol arrayTypeSymbol && 88arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String,

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\HardcodedSymmetricAlgorithmKeysSources.cs (4)

59arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 72arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 88arguments[0].Parameter?.Type is IArrayTypeSymbol arrayTypeSymbol && 96arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String,

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\StringTransferSources.cs (2)

37arguments[0].Parameter is { } firstParameter && 86arguments[1].Parameter is { } secondParameter &&

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AbstractLocationDataFlowOperationVisitor.cs (2)

69Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 75if (operation.Parameter.RefKind == RefKind.Ref)

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityDataFlowOperationVisitor.cs (2)

66Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 82Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out);

src\roslyn\src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (9)

2404if (argument.Parameter?.Type.TypeKind == TypeKind.Delegate || 2405argument.Parameter?.Type.SpecialType == SpecialType.System_Object) 2411if (argument.Parameter.Type.TypeKind == TypeKind.Delegate) 2539if (argument.Parameter != null) 2552if (argumentOperation.Parameter!.ContainingSymbol is IMethodSymbol method && 2561var ordinal = argumentOperation.Parameter.Ordinal; 2570return argumentOperation.Parameter.OriginalDefinition; 3120if (operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) 3123if (operation.Parameter.RefKind != RefKind.Out)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (1)

1633var argument = invocationOperation.Arguments.FirstOrDefault(a => Equals(originalParameter, a.Parameter));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

224if (argumentOp is not { Value.Type: { } valueType, Parameter.Type: { } parameterType })

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (1)

305if (arg is { Parameter: IParameterSymbol param, Value.Syntax: ExpressionSyntax captured })

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordHelpers.cs (1)

305if (arg is { Parameter: IParameterSymbol param, Value.Syntax: ExpressionSyntax captured })

Microsoft.NetCore.Analyzers\Performance\CSharpRecommendCaseInsensitiveStringComparisonFixer.cs (1)

72if (rightOffendingMethod != null && arg.Parameter?.Type?.Name == StringTypeName)

Microsoft.NetCore.Analyzers\Performance\CSharpUseStringMethodCharOverloadWithSingleCharacters.Fixer.cs (2)

34if (argumentOperation?.Parameter != null && argumentOperation.Parameter.Ordinal == 0)

Microsoft.NetCore.Analyzers\Runtime\CSharpForwardCancellationTokenToInvocations.Analyzer.cs (2)

37(a.IsImplicit && a.Parameter != null && !a.Parameter.Type.Equals(cancellationTokenType)) ||

Microsoft.NetCore.Analyzers\Usage\CSharpUseVolatileReadWriteFixer.cs (1)

41var parameterName = volatileWriteParameters[argument.Parameter!.Ordinal].Name;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (1)

1633var argument = invocationOperation.Arguments.FirstOrDefault(a => Equals(originalParameter, a.Parameter));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

224if (argumentOp is not { Value.Type: { } valueType, Parameter.Type: { } parameterType })

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (1)

5930? (oldModel.RequiredModel.GetOperation(oldLambda.Parent, cancellationToken) as IArgumentOperation)?.Parameter

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (6)

323.SelectAsArray(argument => (argument.Parameter!, GenerateArgumentExpression(syntaxGenerator, argument))); 332keySelector: argument => argument.Parameter!, 355argument.Parameter, 383keySelector: argument => argument.Parameter!, 438var parameterSymbol = argument.Parameter; 497var parameterSymbol = argumentOperation.Parameter;

ValueTracking\ValueTracker.FindReferencesProgress.cs (1)

192static (argOp, parameterSymbol) => argOp.Parameter == parameterSymbol && argOp.IsImplicit,

ValueTracking\ValueTracker.OperationCollector.cs (4)

119if (IsContainedIn<IArgumentOperation>(operation, out var argumentOperation) && argumentOperation.Parameter is not null) 121if (argumentOperation.Parameter.IsRefOrOut()) 125return AddOperationAsync(operation, argumentOperation.Parameter, cancellationToken); 231if (argumentOperation.Parameter?.IsRefOrOut() == true)

Microsoft.CodeQuality.Analyzers\Maintainability\DoNotIgnoreMethodResults.cs (3)

318if (argumentOperation?.Parameter == null) 323return IsNUnitThrowsArgument(argumentOperation.Parameter) || IsXunitThrowsArgument(argumentOperation.Parameter);

Microsoft.CodeQuality.Analyzers\Maintainability\UseCrossPlatformIntrinsicsAnalyzer.cs (7)

94SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type) && 95SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[1].Parameter?.Type) && 96(isCommutative || (invocation.Arguments[0].Parameter?.Ordinal == 0)); 102SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type) && 103(invocation.Arguments[1].Parameter?.Type.SpecialType is SpecialType.System_Byte or SpecialType.System_Int32) && 104(invocation.Arguments[0].Parameter?.Ordinal == 0); 110SymbolEqualityComparer.Default.Equals(invocation.Type, invocation.Arguments[0].Parameter?.Type);

Microsoft.CodeQuality.Analyzers\Maintainability\UseNameofInPlaceOfString.cs (2)

56if (argument.Parameter == null 68switch (argument.Parameter.Name)

Microsoft.CodeQuality.Analyzers\QualityGuidelines\AvoidDuplicateElementInitialization.cs (1)

85var parameter = argument.Parameter;

Microsoft.CodeQuality.Analyzers\QualityGuidelines\AvoidMultipleEnumerations\AvoidMultipleEnumerationsHelpers.cs (6)

229argumentOperation.Parameter == null || 244? GetReducedFromParameter(invokingMethod, argumentOperation.Parameter) 245: argumentOperation.Parameter.OriginalDefinition; 292if (argumentOperationToCheck.Parameter == null || 312? GetReducedFromParameter(targetMethod, argumentOperationToCheck.Parameter) 313: argumentOperationToCheck.Parameter;

Microsoft.CodeQuality.Analyzers\QualityGuidelines\DoNotPassDisposablesIntoUnawaitedTasks.cs (1)

66if (!invocation.Arguments.AnyWhere(arg => arg.Parameter?.Type?.AllInterfaces is { Length: > 0 } allInterfaces &&

Microsoft.NetCore.Analyzers\Data\ReviewSqlQueriesForSecurityVulnerabilities.cs (4)

154var potentials = arguments.WhereAsArray(arg => arg.Parameter?.Type.SpecialType == SpecialType.System_String && !arg.Parameter.IsImplicitlyDeclared); 171if (!IsParameterSymbolVulnerable(argument.Parameter!)) 184if (IsParameterSymbolVulnerable(argument.Parameter!) && (isInDbCommandConstructor || isInDataAdapterConstructor))

Microsoft.NetCore.Analyzers\InteropServices\PlatformCompatibilityAnalyzer.cs (2)

467if (argument.Parameter?.Type.SpecialType == SpecialType.System_Int32 && 1442operation.Parameter?.Type.SpecialType == SpecialType.System_String &&

Microsoft.NetCore.Analyzers\Performance\ConstantExpectedAnalyzer.cs (1)

182if (!constantExpectedContext.TryCreateConstantExpectedParameter(argument.Parameter, out var argConstantParameter))

Microsoft.NetCore.Analyzers\Performance\PreferReadOnlySpanOverSpan.cs (3)

296argument.Parameter?.RefKind is RefKind.Ref or RefKind.Out) 351if (SymbolEqualityComparer.Default.Equals(argument.Parameter, parameter)) 357if (argument.Parameter?.Type is INamedTypeSymbol paramType)

Microsoft.NetCore.Analyzers\Performance\UseConcreteTypeAnalyzer.Collector.cs (4)

225if (arg.Parameter != null) 227if (arg.Parameter.RefKind is RefKind.Ref or RefKind.Out) 229RecordAssignment(arg.Value, arg.Parameter.Type); 237RecordAssignment(arg.Parameter, valueType);

Microsoft.NetCore.Analyzers\Performance\UseSearchValues.Fixer.cs (1)

81argumentOperation.Parameter?.Type is INamedTypeSymbol parameterType &&

Microsoft.NetCore.Analyzers\Performance\UseSpanClearInsteadOfFill.cs (1)

81var type = argumentOperation.Parameter?.Type;

Microsoft.NetCore.Analyzers\Runtime\AvoidConstArrays.cs (6)

65if (argumentOperation?.Parameter is null 66|| (argumentOperation.Parameter.IsParams && arrayCreationOperation.IsImplicit) 118if (argumentOperation?.Parameter is not null) 125ITypeSymbol? originalDefinition = argumentOperation.Parameter?.Type.OriginalDefinition; 140if (!isDirectlyInsideLambda && !argumentOperation.Parameter!.ContainingType.Equals(context.ContainingSymbol.ContainingType)) 142paramName = argumentOperation.Parameter.Name;

Microsoft.NetCore.Analyzers\Runtime\AvoidRedundantRegexIsMatchBeforeMatch.cs (5)

487if (isMatchArg.Parameter is null) 495if (candidate.Parameter?.Ordinal == isMatchArg.Parameter.Ordinal) 669argOp.Parameter is not null && 670argOp.Parameter.RefKind is RefKind.Ref or RefKind.Out)

Microsoft.NetCore.Analyzers\Runtime\DoNotPassLiteralsAsLocalizedParameters.cs (2)

71if (argument.Parameter == null) 88AnalyzeArgument(argument.Parameter, containingPropertySymbol: null, operation: argument, reportDiagnostic: operationContext.ReportDiagnostic, GetUseNamingHeuristicOption(operationContext));

Microsoft.NetCore.Analyzers\Runtime\ForwardCancellationTokenToInvocations.Analyzer.cs (3)

144static (a, cancellationTokenType) => cancellationTokenType.Equals(a.Parameter?.Type) && !a.IsImplicit, 307static (a, cancellationTokenType) => a.Parameter != null && a.Parameter.Type.Equals(cancellationTokenType) && a.ArgumentKind == ArgumentKind.DefaultValue,

Microsoft.NetCore.Analyzers\Runtime\InstantiateArgumentExceptionsCorrectly.cs (2)

110if (argument.Parameter?.Type.SpecialType != SpecialType.System_String) 121Diagnostic? diagnostic = CheckArgument(owningSymbol, creation, argument.Parameter, value, context);

Microsoft.NetCore.Analyzers\Runtime\LoggerMessageDefineAnalyzer.cs (2)

153var parameter = argument.Parameter; 162var parameter = argument.Parameter;

Microsoft.NetCore.Analyzers\Runtime\PreferAsSpanOverSubstring.cs (2)

105argument.Parameter != null) 107isSubstringLookup[argument.Parameter.Ordinal] = true;

Microsoft.NetCore.Analyzers\Runtime\PreferAsSpanOverSubstring.Fixer.cs (2)

65IParameterSymbol newParameter = spanBasedOverload.Parameters[argument.Parameter!.Ordinal]; 77string oldArgumentName = argument.Parameter.Name;

Microsoft.NetCore.Analyzers\Runtime\PreferStringContainsOverIndexOf.Fixer.cs (1)

86if (firstArgument.Parameter?.Type.SpecialType == SpecialType.System_Char)

Microsoft.NetCore.Analyzers\Runtime\SpecifyIFormatProvider.cs (2)

253SymbolEqualityComparer.Default.Equals(x.Parameter?.Type, iformatProviderType) 275if (!iformatProviderType.Equals(argument.Parameter?.Type))

Microsoft.NetCore.Analyzers\Runtime\UseSpanBasedStringConcat.Fixer.cs (1)

158if (IsNamedArgument(argument) && symbols.IsAnySubstringStartIndexParameter(argument.Parameter))

Microsoft.NetCore.Analyzers\Security\DoNotInstallRootCert.cs (2)

159if (argumentOperation.Parameter != null && 160x509TypeSymbol.Equals(argumentOperation.Parameter.Type))

Microsoft.NetCore.Analyzers\Security\DoNotUseDSA.cs (2)

130arguments[0].Parameter is { } parameter && 146arguments[0].Parameter is { } firstParameter &&

Microsoft.NetCore.Analyzers\Security\DoNotUseWeakKDFAlgorithm.cs (1)

76var hashAlgorithmNameArgumentOperation = objectCreationOperation.Arguments.FirstOrDefault(s => s.Parameter?.Name == "hashAlgorithm");

Microsoft.NetCore.Analyzers\Security\DoNotUseWeakKDFInsufficientIterationCount.cs (1)

156if (rfc2898DeriveBytesTypeSymbol.Equals(argumentOperation.Parameter?.Type))

Microsoft.NetCore.Analyzers\Security\UseAutoValidateAntiforgeryToken.cs (1)

185.Where(s => s.Parameter?.Name == "filterType")

Microsoft.NetCore.Analyzers\Security\UseContainerLevelAccessPolicy.cs (2)

127s => s.Parameter?.Name == policyIdentifierName && 128s.Parameter.Type.SpecialType == SpecialType.System_String);

Microsoft.NetCore.Analyzers\Security\UseRSAWithSufficientKeySize.cs (3)

90arguments[0].Parameter?.Type.SpecialType == SpecialType.System_Int32 && 129arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String && 145arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String &&

Microsoft.NetCore.Analyzers\Security\UseSecureCookiesASPNetCore.cs (1)

154if (argumentOperation.Parameter?.Type.Equals(cookieOptionsTypeSymbol) == true)

Microsoft.NetCore.Analyzers\Security\UseSharedAccessProtocolHttpsOnly.cs (2)

122var protocolsArgumentOperation = invocationOperation.Arguments.FirstOrDefault(s => s.Parameter?.Name == "protocols" && 123s.Parameter.Type is INamedTypeSymbol namedTypeSymbol &&

Microsoft.NetCore.Analyzers\Tasks\UseValueTasksCorrectly.cs (3)

160if (arg.Parameter != null) 162var originalType = arg.Parameter.Type.OriginalDefinition; 168var originalParameter = arg.Parameter.OriginalDefinition;

src\0437c1690f5501bd\CopyAnalysis.CopyDataFlowOperationVisitor.cs (1)

319Debug.Assert(operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out);

src\11b41c7305441175\PropertySetAnalysis.PropertySetDataFlowOperationVisitor.cs (2)

531if (argumentTypeSymbol == null || argumentOperation.Parameter == null) 540argumentOperation.Parameter.MetadataName,

src\40daf5e1cab76dff\HardcodedBytesSources.cs (4)

49arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 62arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 77arguments[0].Parameter?.Type is IArrayTypeSymbol arrayTypeSymbol && 87arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String,

src\40daf5e1cab76dff\HardcodedSymmetricAlgorithmKeysSources.cs (4)

58arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 71arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String, 87arguments[0].Parameter?.Type is IArrayTypeSymbol arrayTypeSymbol && 95arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String,

src\40daf5e1cab76dff\StringTransferSources.cs (2)

36arguments[0].Parameter is { } firstParameter && 85arguments[1].Parameter is { } secondParameter &&

src\40daf5e1cab76dff\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (15)

291.Where(s => s.Parameter != null && this.GetCachedAbstractValue(s).Kind == TaintedDataAbstractValueKind.Tainted) 292.Select(s => s.Parameter!.Name); 318IArgumentOperation? argumentOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == taintedTarget); 319if (argumentOperation?.Parameter != null) 322this.CacheAbstractValue(argumentOperation, TaintedDataAbstractValue.CreateTainted(argumentOperation.Parameter, argumentOperation.Syntax, method)); 352: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenTaintedTarget); 357: visitedArguments.FirstOrDefault(o => o.Parameter?.Name == ifTaintedParameter); 397IArgumentOperation? thenSanitizedTargetOperation = visitedArguments.FirstOrDefault(o => o.Parameter?.Name == thenSanitizedTarget); 688taintedArgument.Parameter == null) 695&& taintedArgument.Parameter.Type.SpecialType == SpecialType.System_String) 700&& sinkParameters.Contains(taintedArgument.Parameter.MetadataName)) 755&& a.Parameter != null 756&& (a.Parameter.RefKind == RefKind.None 757|| a.Parameter.RefKind == RefKind.Ref 758|| a.Parameter.RefKind == RefKind.In));

src\47c588c5b8785708\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

346if (isNullCheckValidationMethod || HasAnyNullValidationAttribute(argument.Parameter))

src\9382845807600969\AbstractLocationDataFlowOperationVisitor.cs (2)

68Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 74if (operation.Parameter.RefKind == RefKind.Ref)

src\9382845807600969\AnalysisEntityDataFlowOperationVisitor.cs (2)

65Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 81Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out);

src\afc74d572e54ec72\DisposeAnalysis.DisposeDataFlowOperationVisitor.cs (7)

187Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 338operation.Parameter?.RefKind == RefKind.Out && 365if (operation.Parameter?.RefKind is RefKind.Out or RefKind.Ref) 375if (operation.Parameter == null || 376operation.Parameter.RefKind == RefKind.Out) 385DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type), 388IsDisposableCreationSpecialCase(invocation.TargetMethod) && DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type),

src\ffd9070534249528\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (4)

286Debug.Assert(operation.Parameter!.RefKind is RefKind.Ref or RefKind.Out); 304if ((operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) && 316else if (operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) 318if (operation.Parameter.RefKind == RefKind.Ref)

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IOperationExtensions.cs (7)

788if (argumentOperation.Parameter?.Ordinal < minOrdinal && argumentOperation.Value is TOperation to) 790minOrdinal = argumentOperation.Parameter.Ordinal; 861if (argument.Parameter?.Ordinal == parameterIndex) 896RoslynDebug.Assert(argument.Parameter is not null); 897Debug.Assert(parameterOrderedArguments[argument.Parameter.Ordinal] == null); 898parameterOrderedArguments[argument.Parameter.Ordinal] = argument; 1026return argumentOperation.Parameter?.RefKind switch

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Analysis\DisposeAnalysis\DisposeAnalysisHelper.cs (1)

159operation.Parent is IArgumentOperation argument && argument.Parameter?.RefKind == RefKind.Out) &&

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (9)

2401if (argument.Parameter?.Type.TypeKind == TypeKind.Delegate || 2402argument.Parameter?.Type.SpecialType == SpecialType.System_Object) 2408if (argument.Parameter.Type.TypeKind == TypeKind.Delegate) 2536if (argument.Parameter != null) 2549if (argumentOperation.Parameter!.ContainingSymbol is IMethodSymbol method && 2558var ordinal = argumentOperation.Parameter.Ordinal; 2567return argumentOperation.Parameter.OriginalDefinition; 3117if (operation.Parameter?.RefKind is RefKind.Ref or RefKind.Out) 3120if (operation.Parameter.RefKind != RefKind.Out)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

500if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

Microsoft.NetCore.Analyzers\Performance\BasicRecommendCaseInsensitiveStringComparisonFixer.vb (1)

84If rightOffendingMethod IsNot Nothing And arg.Parameter.Type.Name = StringTypeName Then

Microsoft.NetCore.Analyzers\Performance\BasicUseStringMethodCharOverloadWithSingleCharacters.Fixer.vb (2)

29If argumentOperation?.Parameter IsNot Nothing AndAlso argumentOperation.Parameter.Ordinal = 0 Then

Microsoft.NetCore.Analyzers\Usage\BasicUseVolatileReadWriteFixer.vb (1)

32Dim parameterName = volatileWriteParameters(argument.Parameter.Ordinal).Name

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

Parser\ConfigurationBinder.cs (2)

82if (instanceArg.Parameter?.Type.SpecialType is not SpecialType.System_Object) 124if (argument.Parameter?.Ordinal == parameterIndex)

src\768f3af0174e68df\InvocationOperationExtensions.cs (2)

33routeHandlerParameter is { Parameter.Type: {} delegateType } && 61if (argument.Parameter?.Ordinal == routeHandlerArgumentOrdinal)

src\runtime\src\libraries\System.Runtime.InteropServices\gen\Common\OperationExtensions.cs (2)

21if (argument.Parameter?.Ordinal == ordinal) 37if (argument.Parameter?.Ordinal == ordinal)

src\runtime\src\libraries\System.Runtime.InteropServices\gen\Common\OperationExtensions.cs (2)

21if (argument.Parameter?.Ordinal == ordinal) 37if (argument.Parameter?.Ordinal == ordinal)

src\runtime\src\libraries\System.Runtime.InteropServices\gen\Common\OperationExtensions.cs (2)

21if (argument.Parameter?.Ordinal == ordinal) 37if (argument.Parameter?.Ordinal == ordinal)

AbstractDoNotCopyValue.cs (2)

394CheckParameterSymbolInUnsupportedContext(operation, operation.Parameter); 399var parameterRefKind = operation.Parameter.RefKind;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

500if (argument.Parameter?.Ordinal == parameterIndex)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\OperationExtensions.cs (1)

164switch (argumentOperation.Parameter?.RefKind)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Simplification\Simplifiers\CastSimplifier.cs (1)

1633var argument = invocationOperation.Arguments.FirstOrDefault(a => Equals(originalParameter, a.Parameter));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\TypeStyle\CSharpUseImplicitTypeHelper.cs (1)

224if (argumentOp is not { Value.Type: { } valueType, Parameter.Type: { } parameterType })

UpgradeToGeneratedRegexAnalyzer.cs (1)

103string? argumentName = argument.Parameter?.Name;

UpgradeToGeneratedRegexCodeFixer.cs (4)

160where arg.Parameter?.Name is not (UpgradeToGeneratedRegexAnalyzer.OptionsArgumentName or UpgradeToGeneratedRegexAnalyzer.PatternArgumentName) 381.SingleOrDefault(arg => arg.Parameter?.Name == UpgradeToGeneratedRegexAnalyzer.PatternArgumentName) 386IArgumentOperation? optionsArgument = arguments.SingleOrDefault(arg => arg.Parameter?.Name == UpgradeToGeneratedRegexAnalyzer.OptionsArgumentName); 398if (arguments.SingleOrDefault(arg => arg.Parameter?.Name == parameterName) is IArgumentOperation argument)