Type

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationParameterSymbol.cs (1)

27public ITypeSymbol Type { get; } = type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationParameterSymbol.cs (1)

27public ITypeSymbol Type { get; } = type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationParameterSymbol.cs (1)

27public ITypeSymbol Type { get; } = type;

Symbols\PublicModel\ParameterSymbol.cs (1)

26ITypeSymbol IParameterSymbol.Type

Symbols\ParameterSymbol.vb (1)

318Private ReadOnly Property IParameterSymbol_Type As ITypeSymbol Implements IParameterSymbol.Type

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationParameterSymbol.cs (1)

27public ITypeSymbol Type { get; } = type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationParameterSymbol.cs (1)

27public ITypeSymbol Type { get; } = type;

AppHostAnalyzer.cs (1)

92SymbolEqualityComparer.Default.Equals(parameterData.Symbol.Type, wellKnownTypes.Get(SpecialType.System_String))

AspireExportAnalyzer.cs (10)

92!IsBuilderType(method.Parameters[0].Type, wellKnownTypes) || 200parameter.Type.ToDisplayString(), 214var targetType = method.Parameters[0].Type; 246var firstParamType = method.Parameters[0].Type; 272var firstParamType = method.Parameters[0].Type; 283concreteTargetTypeName = GetConcreteResourceBuilderTypeName(method.Parameters[i].Type, wellKnownTypes); 442if (parameter.Type is not INamedTypeSymbol namedType || !IsDelegateType(namedType)) 599var paramType = param.Type; 663var dpType = delegateParam.Type; 1239var type = parameter.Type;

RuntimeSource\Configuration.Binder\ConfigurationBindingGenerator.Parser.cs (6)

583if (IsUnsupportedType(parameter.Type)) 861SymbolEqualityComparer.Default.Equals(element, method.Parameters[0].Type))) 877SymbolEqualityComparer.Default.Equals(key, method.Parameters[0].Type) && 878SymbolEqualityComparer.Default.Equals(element, method.Parameters[1].Type))) 962if (firstParam.Name == "argument" && firstParam.Type.SpecialType == SpecialType.System_Object 963&& secondParam.Name == "paramName" && secondParam.Type.Equals(_typeSymbols.String, SymbolEqualityComparer.Default))

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

45if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[0].Type)) 58if (@params[1].Type.SpecialType is SpecialType.System_String) 62else if (SymbolEqualityComparer.Default.Equals(@params[2].Type, _typeSymbols.ActionOfBinderOptions)) 82if (instanceArg.Parameter?.Type.SpecialType is not SpecialType.System_Object) 114IParameterReferenceOperation p => p.Parameter.Type, 140if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[0].Type)) 161else if (paramCount is 2 && SymbolEqualityComparer.Default.Equals(@params[1].Type, _typeSymbols.ActionOfBinderOptions)) 179else if (paramCount is 3 && SymbolEqualityComparer.Default.Equals(@params[2].Type, _typeSymbols.ActionOfBinderOptions)) 200if (paramCount > 3 || @params[1].Type.SpecialType is not SpecialType.System_String) 211else if (paramCount is 3 && SymbolEqualityComparer.Default.Equals(@params[2].Type, type)) 222if (@params[2].Type.SpecialType is not SpecialType.System_String) 234else if (paramCount is 4 && @params[3].Type.SpecialType is SpecialType.System_Object)

RuntimeSource\Configuration.Binder\Parser\OptionsBuilderConfigurationExtensions.cs (5)

22@params[0].Type is not INamedTypeSymbol { IsGenericType: true } genericType || 51if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[1].Type)) 593 when SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[2].Type) => 79@params[1].Type.SpecialType is SpecialType.System_String && 80SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[2].Type))

RuntimeSource\Configuration.Binder\Parser\OptionsConfigurationServiceCollectionExtensions.cs (7)

23!SymbolEqualityComparer.Default.Equals(_typeSymbols.IServiceCollection, @params[0].Type)) 35if (paramCount is 2 && SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[1].Type)) 41ITypeSymbol? secondParamType = @params[1].Type; 42ITypeSymbol? thirdParamType = @params[2].Type; 60@params[1].Type.SpecialType is SpecialType.System_String && 61SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[2].Type) && 62SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[3].Type))

src\30958ef190fa2467\SyntaxGeneratorInternal.cs (1)

114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue };

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

88parameterSymbol.Type 93if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (22)

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

47return invocation.TargetMethod.Parameters[0].Type;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (3)

110var type1 = parameter1.Type.OriginalDefinition; 111var type2 = parameter2.Type.OriginalDefinition; 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (1)

301type ?? parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

30parameter.Type, 45parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

91.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type)); 469method.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (5)

297type: parameter.Type, 319type: parameter.Type, 351var parameterType = parameter.Type; 400var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

COMAnalyzer.cs (1)

91typeSymbol = parameterSymbol.Type;

DynamicallyAccessedMembersAnalyzer.cs (1)

191if (parameter.GetDynamicallyAccessedMemberTypes() != DynamicallyAccessedMemberTypes.None && !parameter.Type.IsTypeInterestingForDataflow(isByRef: parameter.RefKind is not RefKind.None))

TrimAnalysis\FlowAnnotations.cs (1)

170if (!parameter.OriginalDefinition.Type.IsTypeInterestingForDataflow(isByRef))

TrimAnalysis\HandleCallAction.cs (1)

73if (Visit(param.Type))

TrimAnalysis\ParameterProxy.cs (1)

71public TypeProxy ParameterType => new TypeProxy(ParameterSymbol?.Type ?? Method.Method.ContainingType);

UnsafeMigrationAnalyzerHelpers.cs (2)

62|| method.Parameters.Any(static parameter => ContainsPointerOrFunctionPointer(parameter.Type)), 64|| property.Parameters.Any(static parameter => ContainsPointerOrFunctionPointer(parameter.Type)),

AsyncMethodWithoutCancellation.cs (1)

158if (typeSymbols.Contains(argument.Type))

CallAnalysis\Fixers\LegacyLoggingFixer.cs (2)

185matchParams = invocationArgList[i].Equals(methodSymbol.Parameters[i].Type, SymbolEqualityComparer.Default); 249if (SymbolEqualityComparer.Default.Equals(ctorArg.Type, param.Type))

CallAnalysis\StartsEndsWith.cs (4)

23.Where(m => SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, stringType)) 26(m.Parameters.Length == 2 && SymbolEqualityComparer.Default.Equals(m.Parameters[1].Type, stringCompType))); 29.Where(m => SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, stringType)) 32(m.Parameters.Length == 2 && SymbolEqualityComparer.Default.Equals(m.Parameters[1].Type, stringCompType)));

CallAnalysis\ToInvariantString.cs (1)

32if (method.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(method.Parameters[0].Type, formatProvider))

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

StartupFacts.cs (2)

77return SymbolEqualityComparer.Default.Equals(symbol.Parameters[0].Type, symbols.IServiceCollection); 112if (SymbolEqualityComparer.Default.Equals(symbol.Parameters[i].Type, symbols.IApplicationBuilder))

Http\HeaderDictionaryIndexerAnalyzer.cs (1)

30property.Parameters[0].Type.SpecialType == SpecialType.System_String &&

Kestrel\ListenOnIPv6AnyAnalyzer.cs (1)

101Type: // searching type `System.Net.IPAddress`

RouteEmbeddedLanguage\Infrastructure\RouteUsageDetector.cs (4)

270a => SymbolEqualityComparer.Default.Equals(a.Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Routing_IEndpointRouteBuilder)) || 271a.Type.Implements(wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Routing_IEndpointRouteBuilder)))) 278var delegateParameter = method.Parameters.FirstOrDefault(p => delegateSymbol.IsAssignableFrom(p.Type)); 291var routeStringParameter = method.Parameters.FirstOrDefault(p => SymbolEqualityComparer.Default.Equals(stringSymbol, p.Type) &&

RouteHandlers\AtMostOneFromBodyAttribute.cs (1)

29var fromBodyMetadataInterfaceMembers = asParameterDecoratedParameter.Type.GetMembers().Where(

RouteHandlers\DisallowNonParsableComplexTypesOnParameters.cs (2)

121if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol) 125else if (parameterSymbol.Type is INamedTypeSymbol namedTypeSymbol)

RouteHandlers\RouteHandlerAnalyzer.cs (1)

208var parmeterType = targetMethod.Parameters[DelegateParameterOrdinal].Type;

src\aspnetcore\src\Shared\Roslyn\CodeAnalysisExtensions.cs (1)

194return invocation.TargetMethod.Parameters[0].Type as INamedTypeSymbol;

src\aspnetcore\src\Shared\RoslynUtils\ParsabilityHelper.cs (6)

100methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 110methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 111SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_IFormatProvider)) && 139SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 150SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 151SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_Reflection_ParameterInfo)) &&

src\aspnetcore\src\Shared\RoslynUtils\SymbolExtensions.cs (4)

208IParameterSymbol parameterSymbol => parameterSymbol.Type, 226parameterSymbol.Type is INamedTypeSymbol 241: InnerGetDefaultValueString(parameterSymbol.ExplicitDefaultValue, parameterSymbol.Type); 300var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

InternalUsageAnalyzer.cs (1)

111VisitDeclarationSymbol(context, parameter.Type, method);

InternalUsageAnalyzer.cs (1)

111VisitDeclarationSymbol(context, parameter.Type, method);

ServiceOverrideAnalyzer.cs (1)

112m.Parameters[0].Type.ToDisplayString() ==

StartupHookGenerator.cs (1)

144m.Parameters[0].Type.ToDisplayString() ==

src\aspnetcore\src\Shared\RoslynUtils\ParsabilityHelper.cs (6)

100methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 110methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 111SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_IFormatProvider)) && 139SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 150SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 151SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_Reflection_ParameterInfo)) &&

src\aspnetcore\src\Shared\RoslynUtils\SymbolExtensions.cs (4)

208IParameterSymbol parameterSymbol => parameterSymbol.Type, 226parameterSymbol.Type is INamedTypeSymbol 241: InnerGetDefaultValueString(parameterSymbol.ExplicitDefaultValue, parameterSymbol.Type); 300var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

StaticRouteHandlerModel\Emitters\DiagnosticEmitter.cs (1)

38var typeSymbol = parameterSymbol.Type;

StaticRouteHandlerModel\EndpointParameter.cs (2)

22public EndpointParameter(Endpoint endpoint, IParameterSymbol parameter, WellKnownTypes wellKnownTypes) : this(endpoint, parameter.Type, parameter.Name, wellKnownTypes) 504var key = new ParameterLookupKey(parameter.Name!, parameter.Type);

StaticRouteHandlerModel\InvocationOperationExtensions.cs (1)

33routeHandlerParameter is { Parameter.Type: {} delegateType } &&

src\aspnetcore\src\Shared\Roslyn\CodeAnalysisExtensions.cs (1)

194return invocation.TargetMethod.Parameters[0].Type as INamedTypeSymbol;

TopLevelParameterNameAnalyzer.cs (3)

77parameter.Type.Name, 98if (!IsComplexType(parameter.Type)) 105var type = parameter.Type;

src\aspnetcore\src\Shared\Roslyn\CodeAnalysisExtensions.cs (1)

194return invocation.TargetMethod.Parameters[0].Type as INamedTypeSymbol;

SymbolApiConventionMatcher.cs (2)

48if (!IsTypeMatch(methodParameters[i].Type, conventionParameter.Type, typeMatchBehavior) ||

SymbolApiResponseMetadataProvider.cs (1)

212(parameter.Type.SpecialType & SpecialType.System_Int32) == SpecialType.System_Int32)

XmlComments\XmlComment.InheritDoc.cs (2)

336if (!SymbolEqualityComparer.Default.Equals(left.Parameters[i].Type, right.Parameters[i].Type))

HubClientProxyGenerator.Parser.cs (3)

89if (!SymbolEqualityComparer.Default.Equals(symbol.TypeArguments[0], symbol.Parameters[1].Type)) 106var hubConnectionSymbol = symbol.Parameters[0].Type as INamedTypeSymbol; 317FullyQualifiedTypeName = parameter.Type.ToString()

HubServerProxyGenerator.Parser.cs (3)

96var hubConnectionSymbol = symbol.Parameters[0].Type as INamedTypeSymbol; 305FullyQualifiedTypeName = parameter.Type.ToString() 310switch (parameter.Type)

Compilation\Compilation.cs (1)

1754if (!isContainingAssemblyInReferences(param.Type))

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

803return parameterType != null && symbol.Type.Equals(parameterType);

DocumentationCommentId.cs (2)

506this.GetReferenceGenerator(p.ContainingSymbol).Visit(p.Type); 1472return parameterType != null && symbol.Type.Equals(parameterType, SymbolEqualityComparer.CLRSignature);

Operations\ControlFlowGraphBuilder.cs (8)

2509(ITypeSymbolHelpers.IsNullableType(left.Type) || !ITypeSymbolHelpers.IsNullableType(unaryOperatorMethod.Parameters[0].Type)))) 2597if (unaryOperatorMethod == null ? isLifted : !ITypeSymbolHelpers.IsNullableType(unaryOperatorMethod.Parameters[0].Type)) 2603Debug.Assert(unaryOperatorMethod == null || !ITypeSymbolHelpers.IsNullableType(unaryOperatorMethod.Parameters[0].Type)); 2607else if (unaryOperatorMethod != null && ITypeSymbolHelpers.IsNullableType(unaryOperatorMethod.Parameters[0].Type)) 2609condition = MakeInvalidOperation(unaryOperatorMethod.Parameters[0].Type, condition); 6858Debug.Assert(outParameterArgument is { Parameter: { RefKind: RefKind.Out, Type.SpecialType: SpecialType.System_Boolean } }); 7245operation.Syntax, operation.Parameter.Type, isImplicit: true); 7287operation.Syntax, parameter.Type, constantValue: null, isImplicit: true);

SymbolDisplay\AbstractSymbolDisplayVisitor_Minimal.cs (1)

120return parameterSymbol.Type;

Symbols\Attributes\CommonAttributeData.cs (10)

Symbols\Attributes\MarshalAsAttributeDecoder.cs (1)

102if (attribute.AttributeConstructor.Parameters[0].Type.SpecialType == SpecialType.System_Int16)

MetaAnalyzers\ConfigureGeneratedCodeAnalysisAnalyzer.cs (1)

69if (!SymbolEqualityComparer.Default.Equals(parameter.Type, analysisContext))

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (6)

330.Where(m => m.IsPublic() && m.Parameters.Length > 0 && SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, diagnosticDescriptorType)) 550method.Parameters[0].Type.SpecialType == SpecialType.System_String; 572firstParamArgument.Parameter?.Type.SpecialType == SpecialType.System_String && 600invocation.Arguments[0].Parameter?.Type.SpecialType == SpecialType.System_String && 628if (titleArgument.Parameter?.Type.SpecialType == SpecialType.System_String) 817SymbolEqualityComparer.Default.Equals(argument.Parameter?.Type, localizableStringType))

MetaAnalyzers\EnableConcurrentExecutionAnalyzer.cs (1)

69if (!SymbolEqualityComparer.Default.Equals(parameter.Type, analysisContext))

MetaAnalyzers\Fixers\CompareSymbolsCorrectlyFix.cs (2)

163if (SymbolEqualityComparer.Default.Equals(overload.Parameters[0].Type.OriginalDefinition, iEqualityComparer)) 171else if (SymbolEqualityComparer.Default.Equals(overload.Parameters[^1].Type.OriginalDefinition, iEqualityComparer))

MetaAnalyzers\RegisterActionAnalyzer.cs (6)

275if (parameter.Type is INamedTypeSymbol namedType && 438if (IsContextType(parameter.Type, _compilationStartAnalysisContext, _codeBlockStartAnalysisContext, _operationBlockStartAnalysisContext)) 449if (IsContextType(parameter.Type, _compilationStartAnalysisContext, _codeBlockStartAnalysisContext, _operationBlockStartAnalysisContext)) 540Debug.Assert(IsContextType(contextParameter.Type, _codeBlockStartAnalysisContext, _compilationStartAnalysisContext, _operationBlockStartAnalysisContext)); 541bool isCompilationStartAction = SymbolEqualityComparer.Default.Equals(contextParameter.Type.OriginalDefinition, _compilationStartAnalysisContext.OriginalDefinition); 542bool isOperationBlockStartAction = !isCompilationStartAction && SymbolEqualityComparer.Default.Equals(contextParameter.Type.OriginalDefinition, _operationBlockStartAnalysisContext.OriginalDefinition);

src\30958ef190fa2467\SyntaxGeneratorInternal.cs (1)

114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue };

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

88parameterSymbol.Type 93if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

58AddCoupledNamedTypesCore(builder, parameter.Type, wellKnownTypeProvider);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (22)

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

47return invocation.TargetMethod.Parameters[0].Type;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (3)

110var type1 = parameter1.Type.OriginalDefinition; 111var type2 = parameter2.Type.OriginalDefinition; 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (1)

301type ?? parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

30parameter.Type, 45parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

91.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type)); 469method.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (5)

297type: parameter.Type, 319type: parameter.Type, 351var parameterType = parameter.Type; 400var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

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

697&& taintedArgument.Parameter.Type.SpecialType == SpecialType.System_String)

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

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

243=> PointsToAnalysis.ShouldBeTracked(parameter.Type, IsDisposable) ?

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

67parameter.Type.IsReferenceType &&

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

172if (DisposeOwnershipTransferLikelyTypes.Contains(parameter.Type) || 388DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type), 391IsDisposableCreationSpecialCase(invocation.TargetMethod) && DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type),

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

58AddCoupledNamedTypesCore(builder, parameter.Type, wellKnownTypeProvider);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (22)

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

47return invocation.TargetMethod.Parameters[0].Type;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (3)

110var type1 = parameter1.Type.OriginalDefinition; 111var type2 = parameter2.Type.OriginalDefinition; 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

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

156containingMethod.Parameters.Any(p => _disposeOwnershipTransferLikelyTypes.Contains(p.Type));

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

38(firstParameter.Type.SpecialType == SpecialType.System_String || 39firstParameter.Type.SpecialType == SpecialType.System_Char || 40(firstParameter.Type is IArrayTypeSymbol arrayType && 43(firstParameter.Type is IPointerTypeSymbol pointerType && 87(secondParameter.Type.SpecialType == SpecialType.System_String || 88secondParameter.Type.SpecialType == SpecialType.System_Char || 89(secondParameter.Type is IArrayTypeSymbol arrayType &&

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

350method.Parameters[0].Type.SpecialType == SpecialType.System_Boolean; 993var validationMethods = requiresMethods.Concat(assumeMethods).Concat(assertMethods).OfType<IMethodSymbol>().Where(m => m.IsStatic && m.ReturnsVoid && !m.Parameters.IsEmpty && (m.Parameters[0].Type.SpecialType == SpecialType.System_Boolean)); 2404if (argument.Parameter?.Type.TypeKind == TypeKind.Delegate || 2405argument.Parameter?.Type.SpecialType == SpecialType.System_Object) 2411if (argument.Parameter.Type.TypeKind == TypeKind.Delegate)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

449method.Parameters.Any(static p => p.IsRefOrOut() && p.Type.IsDelegateType())))

src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (4)

233method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 234secondParam.Type.InheritsFromOrEquals(_eventArgsType)) 273if (method is { MetadataName: "GetInstance", IsStatic: true, Parameters: [{ Type.SpecialType: SpecialType.System_String }] } && 295if (parameter.Type.SpecialType != SpecialType.System_Int32)

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (2)

19methodSymbol.Parameters[0].Type.Equals(_serializationInfoType) && 20methodSymbol.Parameters[1].Type.Equals(_streamingContextType) &&

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

849attribute.AttributeConstructor?.Parameters is [_, { Name: "checkId", Type.SpecialType: SpecialType.System_String }, ..] && 858attribute.AttributeConstructor.Parameters[0].Type.SpecialType == SpecialType.System_String &&

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

966methodSymbol.Parameters[0].Type.Equals(memberSymbol.ContainingType))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

89if (linqMethodSymbol.Parameters is [_, { Type: INamedTypeSymbol { Arity: 2 } }])

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (5)

206Equals(parameter1.Type, propertyParameter.Type) && 207Equals(parameter2.Type, propertyType)) is true) 272useSpread = parameter.Type.Equals(convertedType); 282useSpread = method.GetOriginalUnreducedDefinition() is not IMethodSymbol { IsExtensionMethod: true, Parameters: [_, { Type: ITypeParameterSymbol }] };

src\roslyn\src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

139var hasIFormatProvider = parameters[0].Type.Equals(formatProviderType);

src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

803return parameterType != null && symbol.Type.Equals(parameterType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\30958ef190fa2467\SyntaxGeneratorInternal.cs (1)

114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue };

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

88parameterSymbol.Type 93if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol)

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

153var parameterType = parameters[parameterIndex].Type;

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (2)

498compilation, argumentTypeInfo, parameter.Type, 523if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (1)

200[parameter.Type],

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (2)

224constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes)) 258var result = SymbolEquivalenceComparer.Instance.Equals(ctorParameter.Type, ParameterTypes[i]) &&

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (1)

122var conversion = semanticFacts.ClassifyConversion(semanticModel, expression, constructorParameter.Type);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

237var typeLocalName = parameter.Type.GetLocalName(fallback: parameter.Name);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs (1)

38=> _methodSymbol.Parameters.SelectAsArray(p => p.Type);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (1)

99isUnsafe = returnType.RequiresUnsafeModifier() || parameters.Any(static p => p.Type.RequiresUnsafeModifier());

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (1)

224Equals(parameter.Type, cancellationTokenType))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

51if (includeMemberType(parameter.Type) && 151if (IsTypeLessAccessibleThanOtherType(parameter.Type, second, []))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Method.cs (2)

82t => compilation.ClassifyCommonConversion(t.p1.Type, t.p2.Type) is not { IsImplicit: true, Exists: true }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (1)

301type ?? parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

30parameter.Type, 45parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

91.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type)); 469method.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (5)

297type: parameter.Type, 319type: parameter.Type, 351var parameterType = parameter.Type; 400var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

SymbolDisplay\SymbolDisplayVisitor.Members.cs (6)

302symbol = symbol.ReduceExtensionMethod(symbol.Parameters.First().Type) ?? symbol; 646param.Type.Accept(this.NotFirstVisitor); 805CanAddConstant(symbol.Type, symbol.ExplicitDefaultValue); 836AddConstantValue(symbol.Type, symbol.ExplicitDefaultValue); 874!(symbol.IsParams && symbol.Type is { IsRefLikeType: true } or ITypeParameterSymbol { AllowsRefLikeType: true })) 881symbol.Type.Accept(this.NotFirstVisitor);

MetaAnalyzers\CSharpSemanticModelGetDeclaredSymbolAlwaysReturnsNullAnalyzer.cs (1)

66.Select(m => m.Parameters[1].Type);

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

172if (!IsIdentityOrImplicitConversion(compilation, lambdaParameter.Type, invokedParameter.Type))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (4)

56constructorParameter.Type.Name != nameof(IEnumerable<>)) 61if (!Equals(compilation.IEnumerableOfTType(), constructorParameter.Type.OriginalDefinition)) 80var constructorParameterTypeArg = constructorParameter.Type.GetTypeArguments().Single(); 85addParameter.Type.Equals(constructorParameterTypeArg)))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (5)

579if (siblingParameter.Type.IsRefLikeType && 947Type: INamedTypeSymbol 966if (originalCreateMethod.Parameters.All(static p => p.Type is ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method })) 971if (originalCreateMethod.Parameters is [{ IsParams: true, Type: IArrayTypeSymbol { ElementType: ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method } } }]) 994Type: INamedTypeSymbol

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (3)

158if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" }) 279var implementedInterface = firstParameter.Type 291if (!addMethods.Any(m => m.Parameters is [{ Type: var parameterType }] && Equals(parameterType, elementType)))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (5)

78method.OriginalDefinition.Parameters[0].Type.SpecialType == SpecialType.System_Int32; 116=> parameter.Type.SpecialType == SpecialType.System_Int32 && 120=> parameter.Type.SpecialType == SpecialType.System_Int32 && 135p.Parameters[0].Type.Equals(parameterType)) 150m.Parameters[0].Type.Equals(parameterType) &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (1)

254if (parameter?.Type.NullableAnnotation == NullableAnnotation.Annotated)

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (2)

369if (constructor.Parameters.Any(p => p.Type.IsRefLikeType)) 534parameter.Type.Equals(member.GetMemberType(), SymbolEqualityComparer.IncludeNullability))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

957return argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type; 962=> argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

445if (parameter.Type.OriginalDefinition.TypeKind != TypeKind.TypeParameter)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

813if (symbol is IMethodSymbol { Parameters: [{ Type.OriginalDefinition: var parameterType }, ..] } &&

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

1115type.Equals(parameters[0].Type) && 1116type.Equals(parameters[1].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (2)

267var originalParamType = this.OriginalSemanticModel.GetDeclaredSymbol(originalParam).Type; 268var replacedParamType = this.SpeculativeSemanticModel.GetDeclaredSymbol(replacedParam).Type;

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

161ExpressionGenerator.GenerateExpression(parameter.Type, value: null, canUseFieldReference: false))));

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (3)

161if (constructorSymbol is { Parameters: [{ Type: var parameterType }] } && 173else if (!constructorSymbol.Parameters.Select(parameter => parameter.Type) 357.SelectAsArray(parameter => parameter.Type)

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

37methodSymbol.Parameters.First().Type.SpecialType == SpecialType.System_Object && 510if (parameter.Type.Equals(type)) 517else if (parameter.Type.SpecialType == SpecialType.System_Object)

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

186parameterList, parameterList.WithParameters(parameters.Insert(0, Parameter(Identifier("@this")).WithType(thisParameter.Type.GenerateTypeSyntax()))));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseExplicitArrayInExpressionTree\CSharpUseExplicitArrayInExpressionTreeCodeFixProvider.cs (3)

49currentMethod.Parameters is [.., { IsParams: true, Type: IArrayTypeSymbol arrayType }]) 86if (!originalParameter.Type.Equals(currentParameter.Type))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

287parameterNode = parameterNode.WithType(delegateParameter?.Type.GenerateTypeSyntax() ?? s_objectType); 346=> EqualsValueClause(ExpressionGenerator.GenerateExpression(parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (1)

245.SelectMany(p => p.Type.GetReferencedTypeParameters())

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ParameterGenerator.cs (2)

70.WithType(parameter.Type.GenerateTypeSyntax(allowVar: false)) 111=> ExpressionGenerator.GenerateExpression(parameter.Type, value, canUseFieldReference: true);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (1)

168var parameters = symbol.Signature.Parameters.Select(p => (p.Type, RefKindModifiers: CSharpSyntaxGeneratorInternal.GetParameterModifiers(p)))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\WithElementSyntaxExtensions.cs (1)

57static m => m.Parameters is [{ Type.SpecialType: SpecialType.System_Int32, Name: "capacity" }]);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (6)

785.Select(p => new TypeInferenceInfo(p.Type, p.IsParams)); 798var info = new TypeInferenceInfo(parameter.Type, parameter.IsParams); 1227return CreateResult(parameter.Type); 1393.Select(a => new TypeInferenceInfo(a.Parameters.ElementAtOrDefault(parameterIndex)?.Type)) 1411.Select(a => new TypeInferenceInfo(a.Parameters[0].Type)); 1499var addMethodParameterTypes = addMethodSymbols.Select(m => ((IMethodSymbol)m).Parameters[0]).Select(p => new TypeInferenceInfo(p.Type));

ChangeSignature\CSharpChangeSignatureService.cs (1)

925var objectCreation = ArrayCreationExpression((ArrayTypeSyntax)parameterSymbol.Type.GenerateTypeSyntax(), initializerExpression);

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

303.WithType(parameter.Type.GenerateTypeSyntax());

Completion\CompletionProviders\CrefCompletionProvider.cs (1)

310builder.Append(p.Type.ToMinimalDisplayString(semanticModel, position, MinimalParameterTypeFormat));

Completion\CompletionProviders\DeclarationName\DeclarationNameRecommender.cs (1)

322methodParameterType.Equals(overloadParameter.Type, SymbolEqualityComparer.Default))

Completion\CompletionProviders\ExplicitInterfaceMemberCompletionProvider.ItemGetter.cs (1)

258AddType(parameter.Type, builder, semanticModel);

Completion\CompletionProviders\OperatorsAndIndexer\UnnamedSymbolCompletionProvider_Conversions.cs (1)

72var symbols = ImmutableArray.Create<ISymbol>(conversion.ContainingType, conversion.Parameters.First().Type, conversion.ReturnType);

Completion\Providers\DefaultArgumentProvider.cs (3)

31else if (context.Parameter.Type.IsReferenceType || context.Parameter.Type.IsNullable()) 37context.DefaultValue = context.Parameter.Type.SpecialType switch

ConvertToExtension\ConvertToExtensionCodeRefactoringProvider.cs (2)

98firstParameterSymbol.Type.AddReferencedMethodTypeParameters(methodTypeParameters); 167string.Format(CSharpFeaturesResources.Convert_0_extension_methods_to_extension, specificExtension.Value.FirstParameter.Type.ToDisplayString()),

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (4)

111IsImplicitConversion(compilation, source: parameter.Type, destination: field.Type) && 120IsImplicitConversion(compilation, source: parameter.Type, destination: property.Type) && 225parameter.Type, 249parameter.Type,

InlineHints\CSharpInlineTypeHintsService.cs (4)

78IsValidType(parameter?.Type)) 81? new TypeHint(parameter.Type, span, textChange: new TextChange(span, GetTypeDisplayString(parameter.Type) + " "), trailingSpace: true) 82: new TypeHint(parameter.Type, span, textChange: null, trailingSpace: true);

IntroduceParameter\CSharpIntroduceParameterCodeRefactoringProvider.cs (1)

26=> ExpressionGenerator.GenerateExpression(parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue, canUseFieldReference: true);

QuickInfo\OnTheFlyDocsUtilities.cs (1)

16var parameterStrings = symbol.GetParameters().SelectAsArray(parameter => GetOnTheFlyDocsRelevantFileInfo(parameter.Type));

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_DelegateType.cs (1)

65parts.AddRange(parameter.Type.ToMinimalDisplayParts(semanticModel, position));

src\roslyn\src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryLambdaExpression\CSharpRemoveUnnecessaryLambdaExpressionDiagnosticAnalyzer.cs (2)

172if (!IsIdentityOrImplicitConversion(compilation, lambdaParameter.Type, invokedParameter.Type))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (4)

56constructorParameter.Type.Name != nameof(IEnumerable<>)) 61if (!Equals(compilation.IEnumerableOfTType(), constructorParameter.Type.OriginalDefinition)) 80var constructorParameterTypeArg = constructorParameter.Type.GetTypeArguments().Single(); 85addParameter.Type.Equals(constructorParameterTypeArg)))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (5)

579if (siblingParameter.Type.IsRefLikeType && 947Type: INamedTypeSymbol 966if (originalCreateMethod.Parameters.All(static p => p.Type is ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method })) 971if (originalCreateMethod.Parameters is [{ IsParams: true, Type: IArrayTypeSymbol { ElementType: ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method } } }]) 994Type: INamedTypeSymbol

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (3)

158if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" }) 279var implementedInterface = firstParameter.Type 291if (!addMethods.Any(m => m.Parameters is [{ Type: var parameterType }] && Equals(parameterType, elementType)))

src\roslyn\src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (5)

78method.OriginalDefinition.Parameters[0].Type.SpecialType == SpecialType.System_Int32; 116=> parameter.Type.SpecialType == SpecialType.System_Int32 && 120=> parameter.Type.SpecialType == SpecialType.System_Int32 && 135p.Parameters[0].Type.Equals(parameterType)) 150m.Parameters[0].Type.Equals(parameterType) &&

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePatternMatching\CSharpAsAndNullCheckDiagnosticAnalyzer.cs (1)

254if (parameter?.Type.NullableAnnotation == NullableAnnotation.Annotated)

src\roslyn\src\Analyzers\CSharp\Analyzers\UsePrimaryConstructor\CSharpUsePrimaryConstructorDiagnosticAnalyzer.cs (2)

369if (constructor.Parameters.Any(p => p.Type.IsRefLikeType)) 534parameter.Type.Equals(member.GetMemberType(), SymbolEqualityComparer.IncludeNullability))

src\roslyn\src\Analyzers\CSharp\CodeFixes\AssignOutParameters\AbstractAssignOutParametersCodeFixProvider.cs (1)

161ExpressionGenerator.GenerateExpression(parameter.Type, value: null, canUseFieldReference: false))));

src\roslyn\src\Analyzers\CSharp\CodeFixes\ConvertToRecord\ConvertToRecordEngine.cs (3)

161if (constructorSymbol is { Parameters: [{ Type: var parameterType }] } && 173else if (!constructorSymbol.Parameters.Select(parameter => parameter.Type) 357.SelectAsArray(parameter => parameter.Type)

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

37methodSymbol.Parameters.First().Type.SpecialType == SpecialType.System_Object && 510if (parameter.Type.Equals(type)) 517else if (parameter.Type.SpecialType == SpecialType.System_Object)

src\roslyn\src\Analyzers\CSharp\CodeFixes\MakeLocalFunctionStatic\MakeLocalFunctionStaticCodeFixHelper.cs (1)

186parameterList, parameterList.WithParameters(parameters.Insert(0, Parameter(Identifier("@this")).WithType(thisParameter.Type.GenerateTypeSyntax()))));

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseExplicitArrayInExpressionTree\CSharpUseExplicitArrayInExpressionTreeCodeFixProvider.cs (3)

49currentMethod.Parameters is [.., { IsParams: true, Type: IArrayTypeSymbol arrayType }]) 86if (!originalParameter.Type.Equals(currentParameter.Type))

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseLocalFunction\CSharpUseLocalFunctionCodeFixProvider.cs (2)

287parameterNode = parameterNode.WithType(delegateParameter?.Type.GenerateTypeSyntax() ?? s_objectType); 346=> EqualsValueClause(ExpressionGenerator.GenerateExpression(parameter.Type, parameter.ExplicitDefaultValue, canUseFieldReference: true));

UseNamedArguments\CSharpUseNamedArgumentsCodeRefactoringProvider.cs (1)

49var conversion = semanticModel.Compilation.ClassifyConversion(argType, parameters[0].Type);

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

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

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

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

Recommendations\CSharpRecommendationServiceRunner_Conversions.cs (3)

172if (!type.Equals(method.Parameters[0].Type)) 190=> method.ReturnType.IsNonNullableValueType() && method.Parameters.Single().Type.IsNonNullableValueType(); 196TryMakeNullable(compilation, method.Parameters.Single().Type),

Recommendations\CSharpRecommendationServiceRunner_Operators.cs (1)

62if (symbol.IsUserDefinedOperator() && symbol.Parameters.All(p => p.Type.IsValueType))

Recommendations\CSharpRecommendationServiceRunner.cs (1)

878var useBaseReferenceAccessibility = symbol is IParameterSymbol { IsThis: true } p && !p.Type.Equals(containerType);

Rename\CSharpRenameRewriterLanguageService.cs (1)

770matchingLocal is IParameterSymbol { Type.TypeKind: TypeKind.Delegate };

Simplification\CSharpSimplificationService.Expander.cs (4)

181if (parameterSymbols.All(p => p.Type?.ContainsAnonymousType() == false)) 187var typeSyntax = parameterSymbols[i].Type.GenerateTypeSyntax().WithTrailingTrivia(s_oneWhitespaceSeparator); 224if (parameterSymbol?.Type?.ContainsAnonymousType() == false) 226var typeSyntax = parameterSymbol.Type.GenerateTypeSyntax().WithTrailingTrivia(s_oneWhitespaceSeparator);

Simplification\Reducers\CSharpMiscellaneousReducer.cs (2)

57Equals(oldSymbol.Type, newSymbol.Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

957return argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type; 962=> argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

445if (parameter.Type.OriginalDefinition.TypeKind != TypeKind.TypeParameter)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

813if (symbol is IMethodSymbol { Parameters: [{ Type.OriginalDefinition: var parameterType }, ..] } &&

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

1115type.Equals(parameters[0].Type) && 1116type.Equals(parameters[1].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (2)

267var originalParamType = this.OriginalSemanticModel.GetDeclaredSymbol(originalParam).Type; 268var replacedParamType = this.SpeculativeSemanticModel.GetDeclaredSymbol(replacedParam).Type;

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\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (1)

245.SelectMany(p => p.Type.GetReferencedTypeParameters())

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ParameterGenerator.cs (2)

70.WithType(parameter.Type.GenerateTypeSyntax(allowVar: false)) 111=> ExpressionGenerator.GenerateExpression(parameter.Type, value, canUseFieldReference: true);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (1)

168var parameters = symbol.Signature.Parameters.Select(p => (p.Type, RefKindModifiers: CSharpSyntaxGeneratorInternal.GetParameterModifiers(p)))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\WithElementSyntaxExtensions.cs (1)

57static m => m.Parameters is [{ Type.SpecialType: SpecialType.System_Int32, Name: "capacity" }]);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (6)

785.Select(p => new TypeInferenceInfo(p.Type, p.IsParams)); 798var info = new TypeInferenceInfo(parameter.Type, parameter.IsParams); 1227return CreateResult(parameter.Type); 1393.Select(a => new TypeInferenceInfo(a.Parameters.ElementAtOrDefault(parameterIndex)?.Type)) 1411.Select(a => new TypeInferenceInfo(a.Parameters[0].Type)); 1499var addMethodParameterTypes = addMethodSymbols.Select(m => ((IMethodSymbol)m).Parameters[0]).Select(p => new TypeInferenceInfo(p.Type));

Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

Symbols\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

Symbols\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

AddConstructorParametersFromMembers\AddConstructorParametersFromMembersCodeRefactoringProvider.cs (1)

143type: t.parameter.Type,

ChangeSignature\AbstractChangeSignatureService.cs (1)

1062var toType = methodSymbol.Parameters.Last().Type;

Completion\Providers\AbstractContextVariableArgumentProvider.cs (3)

30var requireExactType = context.Parameter.Type.IsSpecialType() 117if (requireExactType && !SymbolEqualityComparer.Default.Equals(context.Parameter.Type, symbolType)) 122var conversion = context.SemanticModel.Compilation.ClassifyCommonConversion(symbolType, context.Parameter.Type);

Completion\Providers\AbstractPartialMethodCompletionProvider.cs (1)

74parameters: method.Parameters.SelectAsArray(p => CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type, p.Name)),

Completion\Providers\ImportCompletionProvider\AbstractExtensionMethodImportCompletionProvider.cs (1)

119IParameterSymbol parameterSymbol => parameterSymbol.Type,

Completion\Providers\ImportCompletionProvider\ExtensionMemberImportCompletionHelper.SymbolComputer.cs (5)

385extensionParameter.Type is ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method } typeParameter) 500if (filterReceiverTypeName.Length > 0 && !string.Equals(filterReceiverTypeName, GetReceiverTypeName(extensionParameter.Type), StringComparison.Ordinal)) 506receiverType = extensionParameter.Type; 516if (filterReceiverTypeName.Length > 0 && !string.Equals(filterReceiverTypeName, GetReceiverTypeName(method.Parameters[0].Type), StringComparison.Ordinal)) 519receiverType = method.Parameters[0].Type;

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

536=> property is { IsIndexer: true, Parameters: [{ Type.SpecialType: SpecialType.System_Int32 }] };

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

875CodeGenerationSymbolFactory.CreateParameterSymbol(RefKind.Out, p.Type, p.Name)),

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (3)

6739SymbolKind.Parameter => ((IParameterSymbol)localOrParameter).Type, 7163=> method.Parameters is [var parameter] && SymbolEqualityComparer.Default.Equals(parameter.Type, compilation.GetTypeByMetadataName(typeof(StringBuilder).FullName!)); 7166=> method.Parameters is [var parameter] && SymbolEqualityComparer.Default.Equals(parameter.Type, method.ContainingType);

EditAndContinue\Utilities\Extensions.cs (3)

214=> symbol is IMethodSymbol { Parameters: [var parameter] } && SymbolEqualityComparer.Default.Equals(parameter.Type, symbol.ContainingType); 220static (param, constructor) => param.RefKind == RefKind.Out && param.Type.Equals(constructor.Parameters[param.Ordinal].Type, SymbolEqualityComparer.Default),

EmbeddedLanguages\EmbeddedLanguageDetector.cs (1)

190m => m is IMethodSymbol { Parameters: [{ Type.SpecialType: SpecialType.System_String }, ..] });

ExtractMethod\MethodExtractor.Analyzer.cs (2)

117&& thisParameterBeingRead is { Type: { TypeKind: TypeKind.Struct, IsReadOnly: false } }; 579IParameterSymbol parameter => parameter.Type,

ExtractMethod\MethodExtractor.TypeParameterCollector.cs (1)

42param.Type.Accept(this);

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

245comparedType.Equals(method.Parameters[1].Type))

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (4)

105let constructorTypes = c.Parameters.Select(p => p.Type) 106let symbolTypes = parameters.Take(c.Parameters.Length).Select(p => p.parameter.Type) 117=> parameters.Select(p => p.parameter.Type).SequenceEqual(constructor.Parameters.Select(p => p.Type));

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (2)

131containingType.Equals(m.Parameters[0].Type) && 132containingType.Equals(m.Parameters[1].Type));

GenerateType\AbstractGenerateTypeService.GenerateNamedType.cs (1)

130static (c, parameterTypes) => c.Parameters.Select(p => p.Type).SequenceEqual(parameterTypes, SymbolEqualityComparer.Default), parameterTypes))

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (13)

124if (parameter.Type.SpecialType == SpecialType.System_String) 209if (parameter.Type.SpecialType == SpecialType.System_String) 283else if (parameter.Type.SpecialType == SpecialType.System_String && 341if (parameter.Type.IsReferenceType) 344if (parameter.Type.NullableAnnotation == NullableAnnotation.Annotated) 347else if (!parameter.Type.IsNullable()) 399if (!parameter.Type.IsSignedIntegralType()) 437var parameterType = parameter.Type; 649var typeOfParameterExpression = generator.TypeOfExpression(generator.TypeExpression(parameter.Type)); 657generator.GenericName(enumIsDefinedGenericMethod.Name, parameter.Type)), 694if (parameter.Type.IsReferenceType && argumentNullExceptionType != null) 698.FirstOrDefault(s => s is IMethodSymbol { Parameters: [{ Type.SpecialType: SpecialType.System_Object }, ..] }); 765.FirstOrDefault(s => s is IMethodSymbol { Parameters: [{ Type.SpecialType: SpecialType.System_String }, ..] });

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (4)

300parameter.Type, uniqueName); 341parameter.Type, 639IsImplicitConversion(compilation, source: parameter.Type, destination: field.Type) && 649IsImplicitConversion(compilation, source: parameter.Type, destination: property.Type) &&

InlineHints\AbstractInlineParameterNameHintsService.cs (1)

243return parameter.Type.SpecialType == SpecialType.System_Boolean;

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

347.LocalDeclarationStatement(parameterSymbol.Type, name, rightHandSideValue);

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

259parameterAndName.parameterSymbol.Type, 281return (TStatementSyntax)syntaxGenerator.LocalDeclarationStatement(parameterSymbol.Type, name, expression);

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

501&& parameterSymbol.Type is IArrayTypeSymbol paramArrayParameter 521return GenerateLiteralExpression(parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue);

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)

613!parameter.Type.Equals(compilation.GetTypeByMetadataName(typeof(CancellationToken)?.FullName!));

LanguageServices\AnonymousTypeDisplayService\AbstractStructuralTypeDisplayService.StructuralTypeCollectorVisitor.cs (1)

114=> symbol.Type.Accept(this);

QuickInfo\CommonSemanticQuickInfoProvider.ErrorVisitor.cs (1)

73=> Visit(symbol.Type);

ReplaceMethodWithProperty\ReplaceMethodWithPropertyCodeRefactoringProvider.cs (1)

138SymbolEqualityComparer.IncludeNullability.Equals(parameter.Type, getMethod.ReturnType) &&

ReplacePropertyWithMethods\ReplacePropertyWithMethodsCodeRefactoringProvider.cs (1)

150comparer.Equals(m.Parameters[0].Type, property.Type));

RQName\RQNodeBuilder.cs (1)

145var parameterType = BuildType(parameter.Type);

Shared\Extensions\ISymbolExtensions_Sorting.cs (3)

78var xParamType = GetNamedType(xParam.Type); 79var yParamType = GetNamedType(yParam.Type); 135return [.. GetMethodOrIndexerOrEventParameters(symbol).Select(p => p.Type.ToMinimalDisplayString(semanticModel, position))];

Shared\Utilities\ExtractTypeHelpers.cs (2)

210return method.Parameters.Any(static (t, arg) => DoesTypeReferenceTypeParameter(t.Type, arg.typeParameter, arg.checkedTypes), (typeParameter, checkedTypes)) || 215return property.Parameters.Any(static (t, arg) => DoesTypeReferenceTypeParameter(t.Type, arg.typeParameter, arg.checkedTypes), (typeParameter, checkedTypes)) ||

src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

449method.Parameters.Any(static p => p.IsRefOrOut() && p.Type.IsDelegateType())))

src\9547feb31df4cc5d\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (4)

233method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 234secondParam.Type.InheritsFromOrEquals(_eventArgsType)) 273if (method is { MetadataName: "GetInstance", IsStatic: true, Parameters: [{ Type.SpecialType: SpecialType.System_String }] } && 295if (parameter.Type.SpecialType != SpecialType.System_Int32)

src\roslyn\src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (2)

19methodSymbol.Parameters[0].Type.Equals(_serializationInfoType) && 20methodSymbol.Parameters[1].Type.Equals(_streamingContextType) &&

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (2)

849attribute.AttributeConstructor?.Parameters is [_, { Name: "checkId", Type.SpecialType: SpecialType.System_String }, ..] && 858attribute.AttributeConstructor.Parameters[0].Type.SpecialType == SpecialType.System_String &&

src\roslyn\src\Analyzers\Core\Analyzers\RemoveUnusedMembers\AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs (1)

966methodSymbol.Parameters[0].Type.Equals(memberSymbol.ContainingType))

src\roslyn\src\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

89if (linqMethodSymbol.Parameters is [_, { Type: INamedTypeSymbol { Arity: 2 } }])

src\roslyn\src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (5)

206Equals(parameter1.Type, propertyParameter.Type) && 207Equals(parameter2.Type, propertyType)) is true) 272useSpread = parameter.Type.Equals(convertedType); 282useSpread = method.GetOriginalUnreducedDefinition() is not IMethodSymbol { IsExtensionMethod: true, Parameters: [_, { Type: ITypeParameterSymbol }] };

src\roslyn\src\Analyzers\Core\Analyzers\ValidateFormatString\AbstractValidateFormatStringDiagnosticAnalyzer.cs (1)

139var hasIFormatProvider = parameters[0].Type.Equals(formatProviderType);

src\roslyn\src\Analyzers\Core\CodeFixes\AddExplicitCast\Fixer.cs (1)

153var parameterType = parameters[parameterIndex].Type;

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AbstractAddParameterCodeFixProvider.cs (2)

498compilation, argumentTypeInfo, parameter.Type, 523if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)

src\roslyn\src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (1)

200[parameter.Type],

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateConstructor\AbstractGenerateConstructorService.State.cs (2)

224constructor.Parameters.Select(p => p.Type).SequenceEqual(ParameterTypes)) 258var result = SymbolEquivalenceComparer.Instance.Equals(ctorParameter.Type, ParameterTypes[i]) &&

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateConstructor\GenerateConstructorHelpers.cs (1)

122var conversion = semanticFacts.ClassifyConversion(semanticModel, expression, constructorParameter.Type);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (1)

237var typeLocalName = parameter.Type.GetLocalName(fallback: parameter.Name);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.MethodSignatureInfo.cs (1)

38=> _methodSymbol.Parameters.SelectAsArray(p => p.Type);

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.SignatureInfo.cs (1)

99isUnsafe = returnType.RequiresUnsafeModifier() || parameters.Any(static p => p.Type.RequiresUnsafeModifier());

src\roslyn\src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.cs (1)

224Equals(parameter.Type, cancellationTokenType))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (2)

51if (includeMemberType(parameter.Type) && 151if (IsTypeLessAccessibleThanOtherType(parameter.Type, second, []))

src\roslyn\src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator_Method.cs (2)

82t => compilation.ClassifyCommonConversion(t.p1.Type, t.p2.Type) is not { IsImplicit: true, Exists: true }))

src\roslyn\src\Compilers\Core\Portable\DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

803return parameterType != null && symbol.Type.Equals(parameterType);

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (1)

101if (!MatchType(paramSymbol.Type, stackFrameParameter.Type))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\CancellationTokenParametersMustComeLast.cs (6)

62if (!methodSymbol.Parameters.Any(static (parameter, tokenType) => parameter.Type.Equals(tokenType), cancellationTokenType)) 102&& !SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[last].Type, cancellationTokenType)) 108if (SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[last].Type, cancellationTokenType)) 118while (last >= 0 && SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[last].Type, cancellationTokenType)) 132&& SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[last].Type.OriginalDefinition, iprogressType)) 139ITypeSymbol parameterType = methodSymbol.Parameters[i].Type;

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DefineAccessorsForAttributeArguments.cs (2)

144if (parameter.Type.Kind != SymbolKind.ErrorType) 147!parameter.Type.IsAssignableTo(property.Type, compilation))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DefineAccessorsForAttributeArguments.Fixer.cs (1)

101editor.Generator.TypeExpression(parameterSymbol.Type),

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotExposeGenericLists.cs (3)

123if (parameter.Type != null && parameter.Type.OriginalDefinition.Equals(genericListType) && 127parameter.Type.ToDisplayString(SymbolDisplayFormats.ShortSymbolDisplayFormat),

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotHideBaseClassMethods.cs (4)

102if (!baseMethodParameter.Type.Equals(derivedMethodParameter.Type)) 104if (!baseMethodParameter.Type.DerivesFrom(derivedMethodParameter.Type))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotRaiseExceptionsInUnexpectedLocations.cs (3)

263if (method.IsImplementationOfInterfaceMethod(method.Parameters.First().Type, iEqualityComparer, WellKnownMemberNames.ObjectEquals)) 271if (method.IsImplementationOfInterfaceMethod(method.Parameters.First().Type, iEquatable, WellKnownMemberNames.ObjectEquals)) 299if (method.IsImplementationOfInterfaceMethod(method.Parameters.First().Type, iEqualityComparer, WellKnownMemberNames.ObjectGetHashCode))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\ImplementStandardExceptionConstructors.cs (3)

92else if (parameters.Length == 1 && parameters[0].Type.SpecialType == SpecialType.System_String) 97else if (parameters.Length == 2 && parameters[0].Type.SpecialType == SpecialType.System_String && 98parameters[1].Type.Equals(exceptionType))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\OperatorOverloadsHaveNamedAlternates.cs (1)

126ExpectedAlternateMethodGroup? expectedGroup = GetExpectedAlternateMethodGroup(operatorName, methodSymbol.ReturnType, methodSymbol.Parameters.FirstOrDefault()?.Type);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\OperatorOverloadsHaveNamedAlternates.Fixer.cs (1)

131ITypeSymbol? parameterType = operatorOverloadSymbol.Parameters.FirstOrDefault()?.Type;

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\OperatorsShouldHaveSymmetricalOverloads.cs (2)

134if (!parameters1[i].Type.Equals(parameters2[i].Type))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\ParameterNamesShouldMatchBaseDeclaration.cs (1)

118if (bestMatchParameter.OriginalDefinition.Type is ITypeParameterSymbol)

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\PassSystemUriObjectsInsteadOfStrings.cs (1)

159if (overload.Parameters[index].Type?.Equals(_uri) == true &&

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\UseIntegralOrStringArgumentForIndexers.cs (1)

87ITypeSymbol paramType = symbol.Parameters[0].Type;

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

Microsoft.CodeQuality.Analyzers\QualityGuidelines\AvoidMultipleEnumerations\AvoidMultipleEnumerations.DataFlowOperationVisitor.cs (1)

36return VisitLocalOrParameter(operation.Parameter.Type?.OriginalDefinition, operation, value);

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

250methodParameter => IsDeferredType(methodParameter.Type?.OriginalDefinition, wellKnownSymbolsInfo.AdditionalDeferredTypes) && methodParameter.Equals(argumentMappingParameter))) 263&& IsDeferredType(argumentMappingParameter.Type?.OriginalDefinition, wellKnownSymbolsInfo.AdditionalDeferredTypes); 317methodParameter => IsDeferredType(methodParameter.Type?.OriginalDefinition, wellKnownSymbolsInfo.AdditionalDeferredTypes) && methodParameter.Equals(argumentMappingParameter.OriginalDefinition))) 384builder.AddRange(type.Constructors.Where(c => c.Parameters.Any(p => p.Type.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T))); 406&& parameters[0].Type.OriginalDefinition.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)

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

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

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

133if (IsMultiDimensionalArray(parameter.Type) &&

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

48!containingMethod.Parameters.Any(p => p.Type.IsReferenceType) ||

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

154var potentials = arguments.WhereAsArray(arg => arg.Parameter?.Type.SpecialType == SpecialType.System_String && !arg.Parameter.IsImplicitlyDeclared);

Microsoft.NetCore.Analyzers\InteropServices\AvoidStringBuilderPInvokeParameters.cs (1)

62if (parameter.Type.Equals(stringBuilderType))

Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshalling.cs (1)

175AnalyzeSignatureType(paramLocation, param.Type);

Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshallingAnalyzer.DelegateInteropUsageAnalyzer.cs (4)

119if (param.Type.TypeKind == TypeKind.Delegate) 121AnalyzeDelegateMethodSignature((INamedTypeSymbol)param.Type, param); 123else if (param.Type is IArrayTypeSymbol { ElementType.TypeKind: TypeKind.Delegate }) 125AnalyzeDelegateMethodSignature((INamedTypeSymbol)((IArrayTypeSymbol)param.Type).ElementType, param);

Microsoft.NetCore.Analyzers\InteropServices\DoNotUseOutAttributeStringPInvokeParameters.cs (1)

62if (parameter.Type.SpecialType == SpecialType.System_String

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

135if (parameter.Type.SpecialType == SpecialType.System_String || parameter.Type.Equals(_stringBuilderType))

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

188m.Parameters[0].Type.Equals(osPlatformType)); 196m.Parameters[0].Type.SpecialType == SpecialType.System_String); 467if (argument.Parameter?.Type.SpecialType == SpecialType.System_Int32 && 1442operation.Parameter?.Type.SpecialType == SpecialType.System_String &&

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

241if (!IsConstantCompatible(parameter.Type)) 378case SpecialType.None when parameterSymbol.Type.TypeKind == TypeKind.TypeParameter: 382diagnostics = DiagnosticHelper.ParameterIsInvalid(parameterSymbol.Type.ToDisplayString(), syntax); 418if (parameterSymbol?.Type.TypeKind is TypeKind.Enum) 420var enumType = (INamedTypeSymbol)parameterSymbol.Type; 425return parameterSymbol?.Type; 489protected Diagnostic CreateConstantInvalidConstantRuleDiagnostic(IArgumentOperation argument) => argument.CreateDiagnostic(CA1857.ConstantInvalidConstantRule, Parameter.Type.ToDisplayString()); 606return ImmutableArray.Create(MinIsIncompatible(parameterSymbol.Type.ToDisplayString(), attributeSyntax)); 608return ImmutableArray.Create(MaxIsIncompatible(parameterSymbol.Type.ToDisplayString(), attributeSyntax)); 610var expectedTypeName = parameterSymbol.Type.ToDisplayString(); 619return ImmutableArray.Create(MinIsOutOfRange(attributeSyntax, typeMinValue, typeMaxValue), MaxIsIncompatible(parameterSymbol.Type.ToDisplayString(), attributeSyntax)); 621return ImmutableArray.Create(MinIsIncompatible(parameterSymbol.Type.ToDisplayString(), attributeSyntax), MaxIsOutOfRange(attributeSyntax, typeMinValue, typeMaxValue));

Microsoft.NetCore.Analyzers\Performance\ConstantExpectedAnalyzer.UnmanagedHelper.cs (2)

186if (Parameter.Type.SpecialType != subsetCandidate.Parameter.Type.SpecialType ||

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

193method = method.ReduceExtensionMethod(method.Parameters[0].Type) ?? method;

Microsoft.NetCore.Analyzers\Performance\PreferConvertToHexStringOverBitConverter.cs (2)

200SymbolEqualityComparer.Default.Equals(stringReplaceMethod.Parameters[0].Type, stringType) && 201SymbolEqualityComparer.Default.Equals(stringReplaceMethod.Parameters[1].Type, stringType);

Microsoft.NetCore.Analyzers\Performance\PreferDictionaryTryMethodsOverContainsKeyGuardAnalyzer.cs (2)

269&& suspected.Parameters.Zip(comparator.Parameters, (p1, p2) => p1.OriginalDefinition.Type.Name == p2.Type.Name).All(isParameterEqual => isParameterEqual);

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

114parameter.Type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat))); 357if (argument.Parameter?.Type is INamedTypeSymbol paramType) 426parameter.Type is INamedTypeSymbol namedType)

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

34GetReadOnlyTypeName(parameterSymbol.Type) is { } targetTypeName) 63if (parameterSymbol?.Type is INamedTypeSymbol namedType && namedType.TypeArguments.Length == 1)

Microsoft.NetCore.Analyzers\Performance\UseCompositeFormat.cs (14)

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

229RecordAssignment(arg.Value, arg.Parameter.Type);

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

225Evaluate(parameter, parameter.Type, assignments, methods, UseConcreteTypeForParameter);

Microsoft.NetCore.Analyzers\Performance\UseSearchValues.cs (2)

127var firstParameterType = method.Parameters[0].Type.OriginalDefinition; 128var secondParameterType = method.Parameters[1].Type.OriginalDefinition;

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\Performance\UseStartsWithInsteadOfIndexOfComparisonWithZero.cs (5)

56if (startsWithMethod.Parameters is [{ Type.SpecialType: SpecialType.System_Char }]) 71if (indexOfMethod.Parameters is [{ Type.SpecialType: SpecialType.System_String }]) 75else if (indexOfMethod.Parameters is [{ Type.SpecialType: SpecialType.System_Char }]) 79else if (indexOfMethod.Parameters is [{ Type.SpecialType: SpecialType.System_String }, { Name: "comparisonType" }]) 83else if (indexOfMethod.Parameters is [{ Type.SpecialType: SpecialType.System_Char }, { Name: "comparisonType" }])

Microsoft.NetCore.Analyzers\Performance\UseStringContainsCharOverloadWithSingleCharactersAnalyzer.cs (2)

56return m.Parameters[0].Type.SpecialType == SpecialType.System_Char; 82&& invokedMethod.Parameters[0].Type.SpecialType.Equals(SpecialType.System_String);

Microsoft.NetCore.Analyzers\Performance\UseStringMethodCharOverloadWithSingleCharacters.cs (2)

84m.Parameters[0].Type.SpecialType == SpecialType.System_Char; 162invokedMethod.Parameters[0].Type.SpecialType == SpecialType.System_String)

Microsoft.NetCore.Analyzers\Runtime\AttributeStringLiteralsShouldParseCorrectly.cs (1)

170if (parameter.Type.SpecialType != SpecialType.System_String)

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

125ITypeSymbol? originalDefinition = argumentOperation.Parameter?.Type.OriginalDefinition;

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

526if (!SymbolEqualityComparer.Default.Equals(left[i].Type, right[i].Type))

Microsoft.NetCore.Analyzers\Runtime\DetectPreviewFeatureAnalyzer.cs (1)

614var parameterType = parameter.Type;

Microsoft.NetCore.Analyzers\Runtime\DisposeObjectsBeforeLosingScope.cs (1)

177if (CanBeDisposable(p.Type))

Microsoft.NetCore.Analyzers\Runtime\DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesAnalyzer.cs (1)

76&& method.Parameters[0].Type.OriginalDefinition.SpecialType

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

227if (parameterSymbol.Type.SpecialType != SpecialType.System_String) 263if (Equals(overridenParameter.Type, parameterSymbol.Type)) 318localizableAttribute.AttributeConstructor.Parameters[0].Type.SpecialType == SpecialType.System_Boolean &&

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

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

110if (argument.Parameter?.Type.SpecialType != SpecialType.System_String) 194if (parameter.Type.SpecialType == SpecialType.System_String

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

169var parameterType = parameter!.Type; 333if (parameter.Type.SpecialType == SpecialType.System_String && 341else if (parameter.Type.SpecialType == SpecialType.System_String &&

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

52stringType.GetMembers("ToLower").OfType<IMethodSymbol>().FirstOrDefault(m => m.Parameters.Length == 1 && Equals(m.Parameters[0].Type, cultureInfo)) : 63stringType.GetMembers("ToUpper").OfType<IMethodSymbol>().FirstOrDefault(m => m.Parameters.Length == 1 && Equals(m.Parameters[0].Type, cultureInfo)) :

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

156if (isSubstringLookup[parameter.Ordinal] && SymbolEqualityComparer.Default.Equals(parameter.Type, symbols.ReadOnlySpanOfCharType)) 163if (!SymbolEqualityComparer.Default.Equals(parameter.Type, oldParameter.Type))

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

68if (symbols.IsAnySubstringInvocation(value) && SymbolEqualityComparer.Default.Equals(newParameter.Type, symbols.ReadOnlySpanOfCharType))

Microsoft.NetCore.Analyzers\Runtime\PreferConstCharOverConstUnitStringAnalyzer.cs (1)

54s.Parameters[0].Type.SpecialType == SpecialType.System_String);

Microsoft.NetCore.Analyzers\Runtime\PreferDictionaryContainsMethods.cs (3)

133ITypeSymbol containsParameterType = containsMethod.Parameters[^1].Type; 148x.Parameters[0].Type.Equals(keyType, SymbolEqualityComparer.Default)); 169x.Parameters[0].Type.Equals(valueType, SymbolEqualityComparer.Default));

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

102if (!SymbolEqualityComparer.Default.Equals(elementParseOverload.Parameters[i].Type, jsonDocumentParseMethod.Parameters[i].Type))

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

159x.Parameters[0].Type is INamedTypeSymbol type && 168x.Parameters[0].Type is INamedTypeSymbol type &&

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

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

Microsoft.NetCore.Analyzers\Runtime\PreferTypedStringBuilderAppendOverloads.cs (11)

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

445if (method.Parameters[formatIndex].Type.SpecialType != SpecialType.System_String) 494if (String.Equals(parameters[i].Type, SymbolEqualityComparer.Default))

Microsoft.NetCore.Analyzers\Runtime\ProvideStreamMemoryBasedAsyncOverrides.cs (1)

167if (!argumentTypes[index].Equals(method.Parameters[index].Type, SymbolEqualityComparer.Default))

Microsoft.NetCore.Analyzers\Runtime\SpecifyCultureInfo.cs (1)

69var correctOverload = correctOverloads.FirstOrDefault(overload => overload.Parameters.Last().Type.Equals(cultureInfoType)) ?? correctOverloads.FirstOrDefault();

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

162.Where(m => m.Parameters is [{ Type.SpecialType: SpecialType.System_String or SpecialType.System_Boolean or SpecialType.System_Char }, var possibleFormatProvider] 163&& possibleFormatProvider.Type.Equals(iformatProviderType, SymbolEqualityComparer.Default)).ToImmutableHashSet(); 167.First(m => m.Parameters is [{ Type.SpecialType: SpecialType.System_String }, var possibleFormatProvider] 168&& possibleFormatProvider.Type.Equals(iformatProviderType, SymbolEqualityComparer.Default))) 171.First(m => m.Parameters is [{ Type.SpecialType: SpecialType.System_String }, var possibleFormatProvider] 172&& possibleFormatProvider.Type.Equals(iformatProviderType, SymbolEqualityComparer.Default))); 231var correctOverload = correctOverloads.FirstOrDefault(overload => overload.Parameters.Last().Type.Equals(iformatProviderType)) ?? correctOverloads.FirstOrDefault(); 253SymbolEqualityComparer.Default.Equals(x.Parameter?.Type, iformatProviderType) 275if (!iformatProviderType.Equals(argument.Parameter?.Type)) 311return type?.GetMembers("ToString").OfType<IMethodSymbol>().FirstOrDefault(s => s.Parameters is [{ Type.SpecialType: SpecialType.System_String }]);

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

177method.Parameters[0].Type.SpecialType == SpecialType.System_String && 178!method.Parameters[^1].Type.Equals(stringComparisonType))

Microsoft.NetCore.Analyzers\Runtime\UseAsyncMethodInAsyncContext.cs (4)

99&& (SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, intType) 100|| SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, timeSpanType))) 274return candidateMethod.Parameters.All(candidateParameter => candidateParameter.HasExplicitDefaultValue || baselineMethod.Parameters.Any(baselineParameter => baselineParameter.Type?.Equals(candidateParameter.Type) ?? false));

Microsoft.NetCore.Analyzers\Runtime\UseOrdinalStringComparison.cs (17)

Microsoft.NetCore.Analyzers\Runtime\UseOrdinalStringComparison.Fixer.cs (10)

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

144if (!SymbolEqualityComparer.Default.Equals(left[i].Type, right[i].Type))

Microsoft.NetCore.Analyzers\Runtime\UseStringEqualsOverStringCompare.cs (1)

135.FirstOrDefault(m => m.GetParameters() is [var param] && param.Type.Equals(intType, SymbolEqualityComparer.Default));

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

181&& targetMethod.Parameters[1].Type.Equals(typeTypeSymbol) 196&& targetMethod.Parameters[0].Type is IArrayTypeSymbol arrayTypeSymbol 221&& targetMethod.Parameters[1].Type.Equals(typeTypeSymbol)

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

112parameterSymbol.Type,

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

59methodSymbol.Parameters[1].Type.SpecialType == SpecialType.System_String)

Microsoft.NetCore.Analyzers\Security\DoNotAlwaysSkipTokenValidationInDelegates.cs (7)

156if (!parameters[0].Type.Equals(iEnumerableString) 157|| !parameters[1].Type.Equals(securityToken) 158|| !parameters[2].Type.Equals(tokenValidationParameters)) 184if (!parameters[0].Type.Equals(nullableDateTime) 185|| !parameters[1].Type.Equals(nullableDateTime) 186|| !parameters[2].Type.Equals(securityToken) 187|| !parameters[3].Type.Equals(tokenValidationParameters))

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

210&& parameters[0].Type.Equals(streamingContextTypeSymbol);

Microsoft.NetCore.Analyzers\Security\DoNotDisableCertificateValidation.cs (4)

140if (!parameters[0].Type.Equals(obj) 141|| !parameters[1].Type.Equals(x509Certificate) 142|| !parameters[2].Type.Equals(x509Chain) 143|| !parameters[3].Type.Equals(sslPolicyErrors))

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

107if (constructorMethod.Parameters[0].Type.Equals(storeNameTypeSymbol)) 111else if (constructorMethod.Parameters[0].Type.SpecialType == SpecialType.System_String) 160x509TypeSymbol.Equals(argumentOperation.Parameter.Type))

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

84methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 85methodSymbol.Parameters[1].Type.SpecialType == SpecialType.System_Boolean);

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

131parameter.Type.SpecialType == SpecialType.System_String && 147firstParameter.Type.SpecialType == SpecialType.System_String &&

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

105&& javaScriptTypeResolverSymbol.Equals(constructorMethod.Parameters[0].Type))

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

169p => jsonSerializerSettingsSymbol.Equals(p.Type))) 173p => jsonSerializerSettingsSymbol.Equals(p.Type)))

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

106constructorMethod.Parameters[2].Type.SpecialType == SpecialType.System_Int32) 156if (rfc2898DeriveBytesTypeSymbol.Equals(argumentOperation.Parameter?.Type))

Microsoft.NetCore.Analyzers\Security\Helpers\SecurityHelpers.cs (1)

182&& methodSymbol.Parameters[0].Type.Equals(xmlReaderTypeSymbol)

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

64s.Parameters[0].Type.Equals(eventArgsTypeSymbol) &&

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

215s.Parameters[0].Type, 237s.Parameters[0].Type,

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

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

123s.Parameter.Type is INamedTypeSymbol namedTypeSymbol &&

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

85methodSymbol.Parameters[0].Type.Equals(xmlReaderTypeSymbol))

Microsoft.NetCore.Analyzers\Tasks\DoNotConfigureAwaitWithSuppressThrowing.cs (1)

48.Where(m => SymbolEqualityComparer.Default.Equals(m.ContainingType, genericTask) && m.Parameters.Length == 1 && SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, configureAwaitOptionsType))

Microsoft.NetCore.Analyzers\Tasks\DoNotCreateTaskCompletionSourceWithWrongArguments.cs (1)

75targetMethod.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

Microsoft.NetCore.Analyzers\Tasks\DoNotCreateTasksWithoutPassingATaskScheduler.cs (1)

66if (invocation.TargetMethod.Parameters.Any(p => p.Type.Equals(taskSchedulerType)))

Microsoft.NetCore.Analyzers\Tasks\DoNotUseNonCancelableTaskDelayWithWhenAny.cs (1)

144if (SymbolEqualityComparer.Default.Equals(parameter.Type, cancellationTokenType))

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

162var originalType = arg.Parameter.Type.OriginalDefinition; 169if (originalParameter.Type.Kind != SymbolKind.TypeParameter)

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

51.FirstOrDefault(m => m.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, _]);

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

225if (!OtherArguments[i].Value.WalkDownConversion().Type.IsAssignableTo(method.Parameters[i].Type, compilation))

Microsoft.NetFramework.Analyzers\Helpers\SecurityDiagnosticHelpers.cs (1)

193ITypeSymbol parameter = method.Parameters[i].Type;

Microsoft.NetFramework.Analyzers\MarkVerbHandlersWithValidateAntiforgeryTokenAnalyzer.MvcAttributeSymbols.cs (1)

92ITypeSymbol parameterType = a.AttributeConstructor.Parameters[0].Type;

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

37(firstParameter.Type.SpecialType == SpecialType.System_String || 38firstParameter.Type.SpecialType == SpecialType.System_Char || 39(firstParameter.Type is IArrayTypeSymbol arrayType && 42(firstParameter.Type is IPointerTypeSymbol pointerType && 86(secondParameter.Type.SpecialType == SpecialType.System_String || 87secondParameter.Type.SpecialType == SpecialType.System_Char || 88(secondParameter.Type is IArrayTypeSymbol arrayType &&

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

695&& taintedArgument.Parameter.Type.SpecialType == SpecialType.System_String)

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

65parameter.Type.IsReferenceType &&

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

169if (DisposeOwnershipTransferLikelyTypes.Contains(parameter.Type) || 385DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type), 388IsDisposableCreationSpecialCase(invocation.TargetMethod) && DisposeOwnershipTransferLikelyTypes.Contains(operation.Parameter.Type),

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

240=> PointsToAnalysis.ShouldBeTracked(parameter.Type, IsDisposable) ?

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

60AddCoupledNamedTypesCore(builder, parameter.Type, wellKnownTypeProvider);

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

57if (!trailingOnly && candidateMethod.Parameters.First().Type.Equals(expectedParameterType) && candidateMethod.Parameters[0].RefKind == RefKind.None) 66if (!lastParameter.Type.Equals(expectedParameterType) || lastParameter.RefKind != RefKind.None) 75if (!selectedOverload.Parameters[i].Type.Equals(candidateMethod.Parameters[j].Type) || 121var parameterType = member.Parameters[i].Type; 157var parameterType = member.Parameters[i].Type; 209if (!member.Parameters[index].Type.Equals(expectedParameterTypesInOrder[index]))

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (27)

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

48return invocation.TargetMethod.Parameters[0].Type;

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\ISymbolExtensions.cs (6)

306return parameters.Where(p => p.Type.Equals(type)); 314return parameters.Where(p => p.Type.SpecialType == specialType); 398var type1 = parameter1.Type.OriginalDefinition; 399var type2 = parameter2.Type.OriginalDefinition; 451if (SymbolEqualityComparer.Default.Equals(overload.Parameters[parameterIndex].Type, type)) 596SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

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

155containingMethod.Parameters.Any(p => _disposeOwnershipTransferLikelyTypes.Contains(p.Type));

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

347method.Parameters[0].Type.SpecialType == SpecialType.System_Boolean; 990var validationMethods = requiresMethods.Concat(assumeMethods).Concat(assertMethods).OfType<IMethodSymbol>().Where(m => m.IsStatic && m.ReturnsVoid && !m.Parameters.IsEmpty && (m.Parameters[0].Type.SpecialType == SpecialType.System_Boolean)); 2401if (argument.Parameter?.Type.TypeKind == TypeKind.Delegate || 2402argument.Parameter?.Type.SpecialType == SpecialType.System_Object) 2408if (argument.Parameter.Type.TypeKind == TypeKind.Delegate)

CSharp\CompilationExtensions.cs (1)

60Parameters: [{ Type: var paramType }]

Language\TagHelpers\Producers\ComponentTagHelperProducer.cs (1)

384Parameters: [{ Type.TypeKind: TypeKind.Delegate }]

Mvc.Version1_X\ViewComponentTagHelperDescriptorFactory.cs (6)

182var typeName = parameter.Type.GetFullName(); 196if (parameter.Type.TypeKind == TypeKind.Enum) 215if (SymbolEqualityComparer.Default.Equals((parameter.Type as INamedTypeSymbol)?.ConstructedFrom, _iDictionarySymbol)) 217dictionaryType = (INamedTypeSymbol)parameter.Type; 219else if (parameter.Type.AllInterfaces.Any(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol))) 221dictionaryType = parameter.Type.AllInterfaces.First(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol));

Mvc.Version2_X\ViewComponentTagHelperDescriptorFactory.cs (6)

197var typeName = parameter.Type.GetFullName(); 211if (parameter.Type.TypeKind == TypeKind.Enum) 230if (SymbolEqualityComparer.Default.Equals((parameter.Type as INamedTypeSymbol)?.ConstructedFrom, _iDictionarySymbol)) 232dictionaryType = (INamedTypeSymbol)parameter.Type; 234else if (parameter.Type.AllInterfaces.Any(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol))) 236dictionaryType = parameter.Type.AllInterfaces.First(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol));

Mvc\ViewComponentTagHelperDescriptorFactory.cs (6)

200var typeName = parameter.Type.GetFullName(); 214if (parameter.Type.TypeKind == TypeKind.Enum) 233if (SymbolEqualityComparer.Default.Equals((parameter.Type as INamedTypeSymbol)?.ConstructedFrom, _iDictionarySymbol)) 235dictionaryType = (INamedTypeSymbol)parameter.Type; 237else if (parameter.Type.AllInterfaces.Any(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol))) 239dictionaryType = parameter.Type.AllInterfaces.First(s => SymbolEqualityComparer.Default.Equals(s.ConstructedFrom, _iDictionarySymbol));

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

58AddCoupledNamedTypesCore(builder, parameter.Type, wellKnownTypeProvider);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (22)

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

47return invocation.TargetMethod.Parameters[0].Type;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (3)

110var type1 = parameter1.Type.OriginalDefinition; 111var type2 = parameter2.Type.OriginalDefinition; 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

SymbolDisplay\SymbolDisplayVisitor.Members.vb (2)

552symbol.Type.Accept(Me.NotFirstVisitor()) 561AddConstantValue(symbol.Type, symbol.ExplicitDefaultValue)

Symbols\ParameterSymbol.vb (1)

318Private ReadOnly Property IParameterSymbol_Type As ITypeSymbol Implements IParameterSymbol.Type

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

247If parameter.Type.TypeKind <> TypeKind.TypeParameter Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

1089expressionTypeOpt.Equals(method.Parameters(0).Type.OriginalDefinition) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Utilities\CastAnalyzer.vb (2)

38If parameter?.IsParams = True AndAlso TypeOf parameter.Type Is IArrayTypeSymbol Then 39Dim parameterType = DirectCast(parameter.Type, IArrayTypeSymbol)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EventGenerator.vb (1)

194Return CodeGenerationSymbolFactory.CreateParameterSymbol(parameter.GetAttributes(), parameter.RefKind, isParams:=False, type:=parameter.Type, name:=parameter.Name, hasDefaultValue:=False)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (5)

42If parameter.Type.IsArrayType() Then 43Dim arrayType = DirectCast(parameter.Type, IArrayTypeSymbol) 61Dim asClause = If(parameter.Type Is Nothing, 63SyntaxFactory.SimpleAsClause(type:=parameter.Type.GenerateTypeSyntax())) 95parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\IMethodSymbolExtensions.vb (2)

32If parameter.Type.TypeKind = TypeKind.Delegate Then 33Dim delegateInvokeMethod = DirectCast(parameter.Type, INamedTypeSymbol).DelegateInvokeMethod

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ParameterSyntaxExtensions.vb (2)

29Equals(oldSymbol.Type, newSymbol.Type) Then

IntroduceParameter\VisualBasicIntroduceParameterCodeRefactoringProvider.vb (1)

23Return GenerateExpression(VisualBasicSyntaxGenerator.Instance, parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue, canUseFieldReference:=True)

SignatureHelp\FunctionAggregationSignatureHelpProvider.vb (2)

144If parameter.Type.TypeKind = TypeKind.Delegate Then 145Dim delegateInvokeMethod = DirectCast(parameter.Type, INamedTypeSymbol).DelegateInvokeMethod

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.DelegateType.vb (1)

68parts.AddRange(parameter.Type.ToMinimalDisplayParts(semanticModel, position))

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

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

Recommendations\VisualBasicRecommendationServiceRunner.vb (1)

257useBaseReferenceAccessibility = Not parameter.Type.Equals(container)

Simplification\VisualBasicSimplificationService.Expander.vb (2)

84Dim conversionType = conversion.MethodSymbol.Parameters(0).Type 108Dim symbolType = newNodeSymbol.Type

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

247If parameter.Type.TypeKind <> TypeKind.TypeParameter Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

1089expressionTypeOpt.Equals(method.Parameters(0).Type.OriginalDefinition) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Utilities\CastAnalyzer.vb (2)

38If parameter?.IsParams = True AndAlso TypeOf parameter.Type Is IArrayTypeSymbol Then 39Dim parameterType = DirectCast(parameter.Type, IArrayTypeSymbol)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\EventGenerator.vb (1)

194Return CodeGenerationSymbolFactory.CreateParameterSymbol(parameter.GetAttributes(), parameter.RefKind, isParams:=False, type:=parameter.Type, name:=parameter.Name, hasDefaultValue:=False)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (5)

42If parameter.Type.IsArrayType() Then 43Dim arrayType = DirectCast(parameter.Type, IArrayTypeSymbol) 61Dim asClause = If(parameter.Type Is Nothing, 63SyntaxFactory.SimpleAsClause(type:=parameter.Type.GenerateTypeSyntax())) 95parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\IMethodSymbolExtensions.vb (2)

32If parameter.Type.TypeKind = TypeKind.Delegate Then 33Dim delegateInvokeMethod = DirectCast(parameter.Type, INamedTypeSymbol).DelegateInvokeMethod

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Extensions\ParameterSyntaxExtensions.vb (1)

29Equals(oldSymbol.Type, newSymbol.Type) Then

Editing\SyntaxGenerator.cs (3)

244method.Parameters.Any(p => p.Type.GetReferencedTypeParameters().Any(t => IsNullableAnnotatedTypeParameter(typeParameter, t))); 326TypeExpression(symbol.Type), 328symbol.HasExplicitDefaultValue ? GenerateExpression(symbol.Type, symbol.ExplicitDefaultValue, canUseFieldReference: true) : null,

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (1)

142lastParameter.Type.IsReadOnlySpan())

Recommendations\AbstractRecommendationServiceRunner.cs (8)

53? GetMemberSymbols(parameter.Type, position, excludeInstance: false, useBaseReferenceAccessibility, unwrapNullable, isForDereference) 126if (!parameterTypeSymbols.Contains(parameter.Type, SymbolEqualityComparer.Default)) 127parameterTypeSymbols = parameterTypeSymbols.Concat(parameter.Type); 228builder.Add(parameters[ordinalInLambda].Type); 241parameterType = method.Parameters.FirstOrDefault(p => _stringComparerForLanguage.Equals(p.Name, argumentName))?.Type; 248if (method.Parameters.LastOrDefault()?.Type is IArrayTypeSymbol arrayType) 262parameterType = method.Parameters[ordinalInInvocation].Type; 424if (originalMember is IMethodSymbol { Parameters: [{ Type: ITypeParameterSymbol parameterType }, ..] })

Rename\ConflictEngine\DeclarationConflictHelpers.cs (1)

114signatureBuilder.Add(new ParameterSignature(parameter.Type, refKind));

Shared\Extensions\IMethodSymbolExtensions.cs (4)

44if (!invoke.Parameters[i].Type.InheritsFromOrEquals(method.Parameters[i].Type)) 83return p1.Select(p => p.Type).ToList().AreMoreSpecificThan([.. p2.Select(p => p.Type)]);

Shared\Extensions\ISymbolExtensions.cs (2)

528if (!left.Parameters[i].Type.Equals(right.Parameters[i].Type))

Shared\Utilities\EditorBrowsableHelpers.cs (3)

43.Where(c => c.Parameters.Length == 1 && Equals(c.Parameters[0].Type, editorBrowsableStateType)); 109(Equals(c.Parameters[0].Type, typeLibFlagsType) || Equals(c.Parameters[0].Type, shortType)));

src\30958ef190fa2467\SyntaxGeneratorInternal.cs (1)

114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue };

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

88parameterSymbol.Type 93if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (1)

301type ?? parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

30parameter.Type, 45parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

91.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type)); 469method.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (5)

297type: parameter.Type, 319type: parameter.Type, 351var parameterType = parameter.Type; 400var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

Rules\MembersMustExist.cs (2)

155if (!_settings.SymbolEqualityComparer.Equals(method.Parameters[i].Type, method.Parameters[i].Type))

SymbolExtensions.cs (2)

158method.Parameters.Select(p => p.Type).SequenceEqual( 159deconstructMethod.Parameters.Select(p => p.Type), SymbolEqualityComparer.Default)));

Analyzers\AppContextDefaultsAnalyzer.cs (2)

147if (methodSym.Parameters[0].Type.SpecialType != SpecialType.System_String) 150if (methodSym.Parameters[1].Type.SpecialType != SpecialType.System_Boolean)

ConfigurationBindingGenerator.Parser.cs (6)

635if (IsUnsupportedType(parameter.Type)) 978SymbolEqualityComparer.Default.Equals(element, method.Parameters[0].Type))) 994SymbolEqualityComparer.Default.Equals(key, method.Parameters[0].Type) && 995SymbolEqualityComparer.Default.Equals(element, method.Parameters[1].Type))) 1079if (firstParam.Name == "argument" && firstParam.Type.SpecialType == SpecialType.System_Object 1080&& secondParam.Name == "paramName" && secondParam.Type.Equals(_typeSymbols.String, SymbolEqualityComparer.Default))

Parser\ConfigurationBinder.cs (12)

45if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[0].Type)) 58if (@params[1].Type.SpecialType is SpecialType.System_String) 62else if (SymbolEqualityComparer.Default.Equals(@params[2].Type, _typeSymbols.ActionOfBinderOptions)) 82if (instanceArg.Parameter?.Type.SpecialType is not SpecialType.System_Object) 114IParameterReferenceOperation p => p.Parameter.Type, 140if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[0].Type)) 161else if (paramCount is 2 && SymbolEqualityComparer.Default.Equals(@params[1].Type, _typeSymbols.ActionOfBinderOptions)) 179else if (paramCount is 3 && SymbolEqualityComparer.Default.Equals(@params[2].Type, _typeSymbols.ActionOfBinderOptions)) 200if (paramCount > 3 || @params[1].Type.SpecialType is not SpecialType.System_String) 211else if (paramCount is 3 && SymbolEqualityComparer.Default.Equals(@params[2].Type, type)) 222if (@params[2].Type.SpecialType is not SpecialType.System_String) 234else if (paramCount is 4 && @params[3].Type.SpecialType is SpecialType.System_Object)

Parser\OptionsBuilderConfigurationExtensions.cs (5)

22@params[0].Type is not INamedTypeSymbol { IsGenericType: true } genericType || 51if (!SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[1].Type)) 593 when SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[2].Type) => 79@params[1].Type.SpecialType is SpecialType.System_String && 80SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[2].Type))

Parser\OptionsConfigurationServiceCollectionExtensions.cs (7)

23!SymbolEqualityComparer.Default.Equals(_typeSymbols.IServiceCollection, @params[0].Type)) 35if (paramCount is 2 && SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[1].Type)) 41ITypeSymbol? secondParamType = @params[1].Type; 42ITypeSymbol? thirdParamType = @params[2].Type; 60@params[1].Type.SpecialType is SpecialType.System_String && 61SymbolEqualityComparer.Default.Equals(_typeSymbols.IConfiguration, @params[2].Type) && 62SymbolEqualityComparer.Default.Equals(_typeSymbols.ActionOfBinderOptions, @params[3].Type))

LoggerMessageGenerator.Parser.cs (2)

367ITypeSymbol paramTypeSymbol = paramSymbol.Type; 743if (IsBaseOrIdentity(parameter.Type, loggerSymbol, sm.Compilation))

LoggerMessageGenerator.Roslyn4.0.cs (1)

58m.Parameters[0].Type.Name == "IFormatProvider" &&

Parser.cs (4)

216&& m.Parameters[0].Type.SpecialType == SpecialType.System_String 217&& SymbolEqualityComparer.Default.Equals(m.Parameters[1].Type, modelType)); 634if (constructorParameters.Length == 1 && constructorParameters[0].Name == "otherProperty" && constructorParameters[0].Type.SpecialType == SpecialType.System_String) 658argumentType = constructorParameters[0].Type;

Extensions\ITypeSymbolExtensions.cs (1)

213return parameter.HasAttribute(skipValidationAttributeSymbol) || parameter.Type.HasAttribute(skipValidationAttributeSymbol);

Parsers\ValidationsGenerator.TypesParser.cs (1)

60_ = TryExtractValidatableType(parameter.Type, wellKnownTypes, validatableTypes, visitedTypes);

src\768f3af0174e68df\InvocationOperationExtensions.cs (1)

33routeHandlerParameter is { Parameter.Type: {} delegateType } &&

src\aspnetcore\src\Shared\RoslynUtils\ParsabilityHelper.cs (6)

100methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 110methodSymbol.Parameters[0].Type.SpecialType == SpecialType.System_String && 111SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_IFormatProvider)) && 139SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 150SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[0].Type, wellKnownTypes.Get(WellKnownType.Microsoft_AspNetCore_Http_HttpContext)) && 151SymbolEqualityComparer.Default.Equals(methodSymbol.Parameters[1].Type, wellKnownTypes.Get(WellKnownType.System_Reflection_ParameterInfo)) &&

src\aspnetcore\src\Shared\RoslynUtils\SymbolExtensions.cs (4)

208IParameterSymbol parameterSymbol => parameterSymbol.Type, 226parameterSymbol.Type is INamedTypeSymbol 241: InnerGetDefaultValueString(parameterSymbol.ExplicitDefaultValue, parameterSymbol.Type); 300var parameterTypes = constructor.Parameters.Select(parameter => $"typeof({parameter.Type.ToDisplayString()})");

Parser.cs (3)

128ci.TypeName = FormatType(ps.Type); 225TypeName = FormatType(p.Type), 229foreach (var attribute in p.Type.GetAttributes())

Parsing\Parser.cs (7)

152&& paramSymbol.Type.Kind != SymbolKind.TypeParameter) 154Diag(DiagDescriptors.DefaultToString, paramSymbol.GetLocation(), paramSymbol.Type, paramSymbol.Name); 189paramSymbol.Type.IsRecord) 192RecordHasSensitivePublicMembers(paramSymbol.Type, symbols)) 536var paramTypeSymbol = paramSymbol.Type; 716if (ParserUtilities.IsBaseOrIdentity(parameter.Type, loggerSymbol, _compilation)) 731isNullable = parameter.Type.NullableAnnotation == NullableAnnotation.Annotated;

Parsing\Parser.LogProperties.cs (2)

36if (!CanLogProperties(paramSymbol, paramSymbol.Type, symbols)) 41var paramTypeSymbol = paramSymbol.Type;

Parsing\Parser.TagProvider.cs (3)

26var paramTypeSymbol = paramSymbol.Type; 101&& SymbolEqualityComparer.Default.Equals(tagCollectorType, method.Parameters[0].Type) 102&& IsAssignableTo(complexObjType, method.Parameters[1].Type))

Parsing\TypeSymbolExtensions.cs (3)

28&& SymbolEqualityComparer.Default.Equals(ts.Parameters[0].Type, symbols.FormatProviderSymbol)) 51&& ts.Parameters[0].Type.SpecialType == SpecialType.System_String 52&& SymbolEqualityComparer.Default.Equals(ts.Parameters[1].Type, symbols.FormatProviderSymbol))

LogParserUtilitiesTests.cs (1)

172paramSymbolMock.SetupGet(x => x.Type)

TypeSymbolExtensionsTests.cs (6)

56Assert.Equal(expectedResult, parameterSymbol.Type.IsEnumerable(symbolHolder)); 100Assert.Equal(expectedResult, parameterSymbol.Type.ImplementsIFormattable(symbolHolder)); 144Assert.Equal(expectedResult, parameterSymbol.Type.ImplementsIConvertible(symbolHolder)); 192Assert.Equal(expectedResult, parameterSymbol.Type.ImplementsISpanFormattable(symbolHolder)); 235Assert.Equal(expectedResult, parameterSymbol.Type.IsSpecialType(symbolHolder)); 279Assert.Equal(expectedResult, parameterSymbol.Type.HasCustomToString());

src\Generators\Microsoft.Gen.ComplianceReports\Parser.cs (3)

128ci.TypeName = FormatType(ps.Type); 225TypeName = FormatType(p.Type), 229foreach (var attribute in p.Type.GetAttributes())

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

536var paramTypeSymbol = paramSymbol.Type;

Parser.cs (1)

536var paramTypeSymbol = paramSymbol.Type;

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

536var paramTypeSymbol = paramSymbol.Type;

src\runtime\src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

240if (parameter.Type.SpecialType == SpecialType.System_Boolean

Analyzers\ConvertToLibraryImportFixer.cs (1)

695if (param.Type.SpecialType is SpecialType.System_String or SpecialType.System_Char)

Analyzers\CustomMarshallerAttributeAnalyzer.cs (9)

894if (!SymbolEqualityComparer.Default.Equals(methods.UnmanagedValuesDestination.Parameters[0].Type, unmanagedType)) 915if (unmanagedType is not null && !SymbolEqualityComparer.Default.Equals(unmanagedType, toManagedMethod.Parameters[0].Type)) 921unmanagedType = toManagedMethod.Parameters[0].Type; 925if (!SymbolEqualityComparer.Default.Equals(methods.UnmanagedValuesSource.Parameters[0].Type, unmanagedType)) 934if (!SymbolEqualityComparer.Default.Equals(methods.ToManaged.Parameters[1].Type, methods.ToManagedFinally.Parameters[1].Type)) 987INamedTypeSymbol allocatedBufferType = (INamedTypeSymbol)callerAllocatedBufferMethod.Parameters[1].Type; 1213if (unmanagedType is not null && !SymbolEqualityComparer.Default.Equals(unmanagedType, fromUnmanagedMethod.Parameters[0].Type)) 1220unmanagedType = fromUnmanagedMethod.Parameters[0].Type;

Analyzers\CustomMarshallerAttributeFixer.cs (7)

363unmanagedType = methods.ToManaged.Parameters[0].Type; 367unmanagedType = methods.ToManagedFinally.Parameters[0].Type; 371unmanagedType = methods.UnmanagedValuesSource.Parameters[0].Type; 375unmanagedType = methods.UnmanagedValuesDestination.Parameters[0].Type; 534unmanagedType = methods.FromUnmanaged.Parameters[0].Type; 538unmanagedType = methods.UnmanagedValuesSource.Parameters[0].Type; 542unmanagedType = methods.UnmanagedValuesDestination.Parameters[0].Type;

Analyzers\NativeMarshallingAttributeAnalyzer.cs (1)

170IParameterSymbol param => param.Type,

src\runtime\src\libraries\System.Runtime.InteropServices\gen\Common\ConvertToSourceGeneratedInteropFixer.cs (1)

240if (parameter.Type.SpecialType == SpecialType.System_Boolean

ManualTypeMarshallingHelper.cs (6)

492nativeType = methods.UnmanagedValuesSource.Parameters[0].Type; 506nativeType = methods.ToManagedFinally.Parameters[0].Type; 510nativeType = methods.ToManaged.Parameters[0].Type; 525bufferElementType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(((INamedTypeSymbol)methods.ToUnmanagedWithBuffer.Parameters[1].Type).TypeArguments[0]); 585nativeType = methods.FromUnmanaged.Parameters[0].Type; 605bufferElementType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(((INamedTypeSymbol)methods.FromManagedWithBuffer.Parameters[1].Type).TypeArguments[0]);

MarshallerShape.cs (22)

221&& SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, managedType)); 263&& SymbolEqualityComparer.Default.Equals(managedType, m.Parameters[0].Type)); 275&& SymbolEqualityComparer.Default.Equals(managedType, m.Parameters[0].Type)); 279if (IsSpanOfUnmanagedType(method.Parameters[1].Type, spanOfT, type)) 315&& managedType.IsConstructedFromEqualTypes(m.Parameters[0].Type) 316&& m.Parameters[1].Type.SpecialType == SpecialType.System_Int32 326&& managedType.IsConstructedFromEqualTypes(m.Parameters[0].Type) 327&& m.Parameters[2].Type.SpecialType == SpecialType.System_Int32 332if (IsSpanOfUnmanagedType(method.Parameters[1].Type, spanOfT, type)) 347&& managedType.IsConstructedFromEqualTypes(m.Parameters[0].Type) 357&& m.Parameters[1].Type.SpecialType == SpecialType.System_Int32 367&& m.Parameters[1].Type.SpecialType == SpecialType.System_Int32 377&& m.Parameters[1].Type.SpecialType == SpecialType.System_Int32 387&& managedType.IsConstructedFromEqualTypes(m.Parameters[0].Type) 397&& m.Parameters[1].Type.SpecialType == SpecialType.System_Int32 566&& SymbolEqualityComparer.Default.Equals(managedType, m.Parameters[0].Type)); 577&& SymbolEqualityComparer.Default.Equals(managedType, m.Parameters[0].Type)); 581if (StatelessMarshallerShapeHelper.IsSpanOfUnmanagedType(method.Parameters[1].Type, spanOfT, type)) 641if (SymbolEqualityComparer.Default.Equals(candidates[0].Parameters[0].Type, unmanagedType)) 672&& SymbolEqualityComparer.Default.Equals(m.Parameters[0].Type, managedType)); 709&& m.Parameters[0].Type.SpecialType == SpecialType.System_Int32 719&& m.Parameters[0].Type.SpecialType == SpecialType.System_Int32

MethodSignatureElementInfoProvider.cs (2)

50marshallingInfoCallback(param.Type, new UseSiteAttributeProvider(_useSiteAttributeParsers, param.GetAttributes(), rootProvider, _generatorDiagnostics, marshallingInfoCallback), 0), _compilation) with 72marshallingInfoCallback(param.Type, new UseSiteAttributeProvider(_useSiteAttributeParsers, param.GetAttributes(), rootProvider, _generatorDiagnostics, marshallingInfoCallback), 0), _compilation) with

SignatureContext.cs (1)

132MarshallingInfo marshallingInfo = marshallingInfoParser.ParseMarshallingInfo(param.Type, paramAttributes);

TypePositionInfo.cs (1)

88var typeInfo = new TypePositionInfo(ManagedTypeInfo.CreateTypeInfoForTypeSymbol(paramSymbol.Type), marshallingInfo)

BindingSourceGenerator.cs (2)

213 if (parameters.Length == 0 || parameters[0].Type is IErrorTypeSymbol) 218 var lambdaParamType = parameters[0].Type;

AbstractDoNotCopyValue.cs (1)

1582CheckTypeSymbolInUnsupportedContext(operation, parameter.Type);

IRemoteJsonServiceParameterAnalyzer.cs (3)

74if (!Equals(parameter.Type, razorPinnedSolutionInfoWrapper) && 75!Equals(parameter.Type, documentId)) 86parameter.Type.Name);

src\30958ef190fa2467\SyntaxGeneratorInternal.cs (1)

114or { RefKind: RefKind.None, Type.IsRefLikeType: true, ScopedKind: ScopedKind.ScopedValue };

src\60c94c676d650713\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

51parameter.Type.Accept(this);

src\60c94c676d650713\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

52symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 70symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

88parameterSymbol.Type 93if (parameterSymbol.Type is IArrayTypeSymbol arrayTypeSymbol)

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

58AddCoupledNamedTypesCore(builder, parameter.Type, wellKnownTypeProvider);

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (22)

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

47return invocation.TargetMethod.Parameters[0].Type;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (3)

110var type1 = parameter1.Type.OriginalDefinition; 111var type2 = parameter2.Type.OriginalDefinition; 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\CollectionExpressionUtilities.cs (2)

98var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 169Equals(lastParameter.Type.OriginalDefinition, readonlySpanOfTType))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BuiltinOperatorSymbolKey.cs (1)

30static (contextualSymbol, i) => SafeGet(contextualSymbol.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

38/// the "same" <see cref="IParameterSymbol.Type"/>s and 62/// the "same" <see cref="IParameterSymbol.Type"/>s and

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.FunctionPointerTypeSymbolKey.cs (1)

58static (contextualSymbol, i) => SafeGet(contextualSymbol.Signature.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

256getContextualType: static (method, i) => SafeGet(method.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.PropertySymbolKey.cs (1)

98getContextualType: static (property, i) => SafeGet(property.OriginalDefinition.Parameters, i)?.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyReader.cs (1)

402if (!signatureComparer.Equals(originalParameterTypes[i], parameters[i].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (1)

80_writeParameterType = p => WriteSymbolKey(p.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\AbstractSpeculationAnalyzer.cs (2)

475CompareAcrossSemanticModels(parameterSymbol.Type, newParameterSymbol.Type);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\LightweightOverloadResolution.cs (1)

136var type = parameter.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\IMethodSymbolExtensions.cs (2)

74method.Parameters is [{ Type.SpecialType: SpecialType.System_Object }, var secondParam] && 75secondParam.Type.InheritsFromOrEquals(eventArgsType);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\INamedTypeSymbolExtensions.cs (1)

250return method.Parameters.Any(static (p, within) => p.Type.Equals(within, SymbolEqualityComparer.Default), within);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions_Accessibility.cs (1)

115if (!IsSymbolAccessibleCore(param.Type, within, null, out failedThroughTypeCheck))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.cs (5)

346IParameterSymbol parameterSymbol => parameterSymbol.Type, 414return ((IParameterSymbol)symbol).Type; 514.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 673IParameterSymbol parameterSymbol => parameterSymbol.Type, 740if (!methods.Any(x => x is { Name: WellKnownMemberNames.OnCompleted, ReturnsVoid: true, Parameters: [{ Type.TypeKind: TypeKind.Delegate }] }))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ISymbolExtensions.RequiresUnsafeModifierVisitor.cs (1)

128return symbol.Type.Accept(this);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

37accessibility = AccessibilityUtilities.Minimum(accessibility, parameter.Type.Accept(this));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

570AreEquivalent(x.Type, y.Type, equivalentTypesWithDifferingAssemblies) &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

231GetHashCode(x.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (1)

301type ?? parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IMethodSymbolExtensions.cs (2)

71CodeGenerationSymbolFactory.CreateParameterSymbol(p.GetAttributes(), p.RefKind, p.IsParams, p.Type.SubstituteTypes(mapping, typeGenerator), p.Name, p.IsOptional, 168p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IParameterSymbolExtensions.cs (2)

30parameter.Type, 45parameter.Type,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\IPropertySymbolExtensions.cs (1)

63p.RefKind, p.IsParams, p.Type, p.Name, p.IsOptional,

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions_CreateEqualsMethod.cs (2)

91.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type)); 469method.Parameters[0].Type.SpecialType == SpecialType.System_Object &&

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\Extensions\SyntaxGeneratorExtensions.cs (5)

297type: parameter.Type, 319type: parameter.Type, 351var parameterType = parameter.Type; 400var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

CSharpDoNotUseDebugAssertForInterpolatedStrings.cs (2)

51if (member is IMethodSymbol { Parameters: [{ Type.SpecialType: SpecialType.System_Boolean }, { Type.SpecialType: SpecialType.System_String }] } method)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (2)

957return argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type; 962=> argument.DetermineParameter(semanticModel, allowUncertainCandidates: false, allowParams: true, cancellationToken)?.Type;

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SemanticModelExtensions.cs (1)

445if (parameter.Type.OriginalDefinition.TypeKind != TypeKind.TypeParameter)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\SyntaxNodeExtensions.cs (1)

813if (symbol is IMethodSymbol { Parameters: [{ Type.OriginalDefinition: var parameterType }, ..] } &&

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

1115type.Equals(parameters[0].Type) && 1116type.Equals(parameters[1].Type))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Utilities\SpeculationAnalyzer.cs (2)

267var originalParamType = this.OriginalSemanticModel.GetDeclaredSymbol(originalParam).Type; 268var replacedParamType = this.SpeculativeSemanticModel.GetDeclaredSymbol(replacedParam).Type;

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\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\MethodGenerator.cs (1)

245.SelectMany(p => p.Type.GetReferencedTypeParameters())

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\ParameterGenerator.cs (2)

70.WithType(parameter.Type.GenerateTypeSyntax(allowVar: false)) 111=> ExpressionGenerator.GenerateExpression(parameter.Type, value, canUseFieldReference: true);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs (1)

168var parameters = symbol.Signature.Parameters.Select(p => (p.Type, RefKindModifiers: CSharpSyntaxGeneratorInternal.GetParameterModifiers(p)))

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\WithElementSyntaxExtensions.cs (1)

57static m => m.Parameters is [{ Type.SpecialType: SpecialType.System_Int32, Name: "capacity" }]);

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpTypeInferenceService.TypeInferrer.cs (6)

785.Select(p => new TypeInferenceInfo(p.Type, p.IsParams)); 798var info = new TypeInferenceInfo(parameter.Type, parameter.IsParams); 1227return CreateResult(parameter.Type); 1393.Select(a => new TypeInferenceInfo(a.Parameters.ElementAtOrDefault(parameterIndex)?.Type)) 1411.Select(a => new TypeInferenceInfo(a.Parameters[0].Type)); 1499var addMethodParameterTypes = addMethodSymbols.Select(m => ((IMethodSymbol)m).Parameters[0]).Select(p => new TypeInferenceInfo(p.Type));

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

247If parameter.Type.TypeKind <> TypeKind.TypeParameter Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SyntaxNodeExtensions.vb (1)

1089expressionTypeOpt.Equals(method.Parameters(0).Type.OriginalDefinition) Then

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Utilities\CastAnalyzer.vb (2)

38If parameter?.IsParams = True AndAlso TypeOf parameter.Type Is IArrayTypeSymbol Then 39Dim parameterType = DirectCast(parameter.Type, IArrayTypeSymbol)

Helpers\RoslynExtensions.cs (2)

732if (parameter.Type.IsNullableType()) 739return !IsInputTypeNonNullable(parameter, parameter.Type);

JsonSourceGenerator.Parser.cs (5)

1595ITypeSymbol caseType = parameter.Type; 2781if (parameterInfo.Type.IsRefLikeType) 2793parameterTypeRef = new TypeRef(parameterInfo.Type); 2797parameterTypeRef = EnqueueType(parameterInfo.Type, typeToGenerate.Mode); 2800AddExperimentalDiagnosticIds(parameterInfo.Type, ref experimentalIds);

System\Windows\Forms\CSharp\Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.cs (1)

57if (funcParameter.Type is not INamedTypeSymbol funcType

Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.vb (2)

56If Not (TypeOf funcParameter.Type Is INamedTypeSymbol) Then 60Dim funcType = DirectCast(funcParameter.Type, INamedTypeSymbol)