Type

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\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\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (2)

253useSpread = parameter.Type.Equals(convertedType); 263useSpread = method.GetOriginalUnreducedDefinition() is not IMethodSymbol { IsExtensionMethod: true, Parameters: [_, { Type: ITypeParameterSymbol }] };

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

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

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

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

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

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

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

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

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

344IParameterSymbol parameterSymbol => parameterSymbol.Type, 412return ((IParameterSymbol)symbol).Type; 512.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 630IParameterSymbol parameterSymbol => parameterSymbol.Type, 697if (!methods.Any(x => x.Name == WellKnownMemberNames.OnCompleted && x.ReturnsVoid && x.Parameters is [{ Type.TypeKind: TypeKind.Delegate }]))

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

126return symbol.Type.Accept(this);

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

46parameter.Type.Accept(this);

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

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

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

37/// the "same" <see cref="IParameterSymbol.Type"/>s and 61/// the "same" <see cref="IParameterSymbol.Type"/>s and

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

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

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

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

228GetHashCode(x.Type,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

50symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 68symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

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

153var parameterType = parameters[parameterIndex].Type;

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

497compilation, argumentTypeInfo, parameter.Type, 522if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)

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

201[parameter.Type],

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

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

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

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

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

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

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

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

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

221Equals(parameter.Type, cancellationTokenType))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (1)

154if (IsTypeLessAccessibleThanOtherType(parameter.Type, second, []))

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

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

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

306type ?? parameter.Type,

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

30parameter.Type, 45parameter.Type,

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

305type: parameter.Type, 327type: parameter.Type, 359var parameterType = parameter.Type; 408var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

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

80.Single(m => containingType.Equals(m.Parameters.FirstOrDefault()?.Type));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

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

SymbolDisplay\SymbolDisplayVisitor.Members.cs (6)

302symbol = symbol.ReduceExtensionMethod(symbol.Parameters.First().Type) ?? symbol; 645param.Type.Accept(this.NotFirstVisitor); 804CanAddConstant(symbol.Type, symbol.ExplicitDefaultValue); 840!(symbol.IsParams && symbol.Type is { IsRefLikeType: true } or ITypeParameterSymbol { AllowsRefLikeType: true })) 847symbol.Type.Accept(this.NotFirstVisitor); 870AddConstantValue(symbol.Type, symbol.ExplicitDefaultValue);

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

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

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (2)

55parameter.Type.Name != nameof(IEnumerable<int>)) 60if (!Equals(compilation.IEnumerableOfTType(), parameter.Type.OriginalDefinition))

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\UseCollectionExpressionHelpers.cs (6)

354var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 610if (siblingParameter.Type.IsRefLikeType && 934Type: INamedTypeSymbol 953if (originalCreateMethod.Parameters.All(static p => p.Type is ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method })) 958if (originalCreateMethod.Parameters is [{ IsParams: true, Type: IArrayTypeSymbol { ElementType: ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method } } }]) 981Type: INamedTypeSymbol

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

74if (Equals(firstParameter.Type.OriginalDefinition, ienumerableOfTType) || 75firstParameter.Type.AllInterfaces.Any(i => Equals(i.OriginalDefinition, ienumerableOfTType))) 82else if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" })

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

80method.OriginalDefinition.Parameters[0].Type.SpecialType == SpecialType.System_Int32; 118=> parameter.Type.SpecialType == SpecialType.System_Int32 && 122=> parameter.Type.SpecialType == SpecialType.System_Int32 && 137p.Parameters[0].Type.Equals(parameterType)) 152m.Parameters[0].Type.Equals(parameterType) &&

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

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

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

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

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

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

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

826expressionType.Equals(method.Parameters[0].Type?.OriginalDefinition))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

71.WithType(parameter.Type.GenerateTypeSyntax()) 113=> ExpressionGenerator.GenerateExpression(generator, parameter.Type, value, canUseFieldReference: true);

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

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

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

781.Select(p => new TypeInferenceInfo(p.Type, p.IsParams)); 794var info = new TypeInferenceInfo(parameter.Type, parameter.IsParams); 1223return CreateResult(parameter.Type);

SymbolKey\SymbolKeyMetadataVsSourceTests.cs (3)

83var member04 = (typesym.GetMembers("M").Single() as IMethodSymbol).Parameters[0].Type; 248var mtsym20_2 = mem20_2.Parameters[0].Type; 251var mtsym20_3 = mem20_2.Parameters[1].Type;

SymbolKey\SymbolKeyTests.cs (1)

171var parameterType = callbackParamater.Type;

CodeGen\CodeGenFunctionPointersTests.cs (1)

7423Assert.True(lambdaSymbol.Parameters.Single().Type.IsErrorType());

CodeGen\CodeGenLocalFunctionTests.cs (15)

CodeGen\CodeGenTupleTest.cs (2)

14254m1Tuple = (INamedTypeSymbol)((IMethodSymbol)symbolInfo.Symbol).Parameters[0].Type; 14348m6Tuple = m6Method.Parameters.Last().Type;

CodeGen\IndexAndRangeTests.cs (1)

1002Assert.Equal(SpecialType.System_Int32, property.Parameters[0].Type.SpecialType);

ChangeSignature\CSharpChangeSignatureService.cs (1)

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

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

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

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

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

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

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

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (1)

596Parameters: [{ Type.SpecialType: SpecialType.System_Boolean }],

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (2)

226parameter.Type, 250parameter.Type,

InlineHints\CSharpInlineTypeHintsService.cs (4)

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

IntroduceParameter\CSharpIntroduceParameterCodeRefactoringProvider.cs (1)

30return ExpressionGenerator.GenerateExpression(CSharpSyntaxGenerator.Instance, parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue, canUseFieldReference: true);

SignatureHelp\LightweightOverloadResolution.cs (1)

123var type = parameter.Type;

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider_DelegateType.cs (1)

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

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

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

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (2)

55parameter.Type.Name != nameof(IEnumerable<int>)) 60if (!Equals(compilation.IEnumerableOfTType(), parameter.Type.OriginalDefinition))

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

354var capacityConstructor = GetAccessibleInstanceConstructor(constructors, c => c.Parameters is [{ Name: "capacity", Type.SpecialType: SpecialType.System_Int32 }]); 934Type: INamedTypeSymbol 953if (originalCreateMethod.Parameters.All(static p => p.Type is ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method })) 958if (originalCreateMethod.Parameters is [{ IsParams: true, Type: IArrayTypeSymbol { ElementType: ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method } } }]) 981Type: INamedTypeSymbol

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

74if (Equals(firstParameter.Type.OriginalDefinition, ienumerableOfTType) || 75firstParameter.Type.AllInterfaces.Any(i => Equals(i.OriginalDefinition, ienumerableOfTType))) 82else if (firstParameter is { Type.SpecialType: SpecialType.System_Int32, Name: "capacity" })

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

80method.OriginalDefinition.Parameters[0].Type.SpecialType == SpecialType.System_Int32; 118=> parameter.Type.SpecialType == SpecialType.System_Int32 && 122=> parameter.Type.SpecialType == SpecialType.System_Int32 && 137p.Parameters[0].Type.Equals(parameterType)) 152m.Parameters[0].Type.Equals(parameterType) &&

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

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

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

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

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

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

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

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

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

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

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

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

UseNamedArguments\CSharpUseNamedArgumentsCodeRefactoringProvider.cs (1)

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

IOperation\FunctionPointerOperations.cs (1)

210Assert.Equal(SpecialType.System_String, signature.Parameters[0].Type.SpecialType);

Semantics\FunctionPointerTests.cs (6)

1620var functionPointer = (IFunctionPointerTypeSymbol)methodSymbol.Parameters[0].Type; 1621Assert.Equal(SpecialType.System_String, functionPointer.Signature.Parameters[0].Type.SpecialType); 1780var functionPointer = (IFunctionPointerTypeSymbol)methodSymbol.Parameters[0].Type; 1941var functionPointer = (IFunctionPointerTypeSymbol)m1InvocationSymbol.Parameters[0].Type; 1943Assert.Equal(TypeKind.TypeParameter, functionPointer.Signature.Parameters[0].Type.TypeKind); 1947Assert.True(declaredSymbol.TypeParameters[0].Equals(functionPointer.Signature.Parameters[0].Type, TypeCompareKind.ConsiderEverything));

Semantics\LambdaDiscardParametersTests.cs (2)

114Assert.Equal(expectedType, symbol1.Type.ToTestDisplayString()); 117Assert.Equal(expectedType, symbol1.Type.ToTestDisplayString());

Semantics\LambdaTests.cs (5)

2668Assert.False(parameter.Type.IsErrorType()); 2671Assert.False(parameter.Type.IsErrorType()); 2674Assert.Equal(tooMany, parameter.Type.IsErrorType()); 2681Assert.False(parameter.Type.IsErrorType()); 2684Assert.Equal(tooMany, parameter.Type.IsErrorType());

Semantics\LocalFunctionTests.cs (2)

5119Assert.Equal(expected, parameterSymbol.Type.ToTestDisplayString()); 5120Assert.Same(symbol, parameterSymbol.Type);

Semantics\NativeIntegerTests.cs (2)

3641var underlyingType0 = method.Parameters[0].Type.GetSymbol<NamedTypeSymbol>(); 3642var underlyingType1 = method.Parameters[1].Type.GetSymbol<NamedTypeSymbol>();

Semantics\OperatorTests.cs (14)

Semantics\SemanticErrorTests.cs (1)

3347var paramTypeSymbol = constructedMethodSymbol.Parameters.Single().Type;

Semantics\UnsafeTests.cs (4)

8876summaryMethod.Name, summaryMethod.ReturnType, summaryMethod.Parameters[0].Type, summaryMethod.Parameters[1].Type); 9338summaryMethod.Name, summaryMethod.ReturnType, summaryMethod.Parameters[0].Type, summaryMethod.Parameters[1].Type);

Semantics\Utf8StringsLiteralsTests.cs (2)

4089method.Name, method.ReturnType, method.Parameters[0].Type, method.Parameters[1].Type);

Compilation\GetSemanticInfoTests.cs (5)

1170Assert.Equal(systemActionType, parameterSymbol.Type); 1199Assert.Equal(systemActionType, parameterSymbol.Type); 1818Assert.Equal(TypeKind.Array, candidate.Parameters.Last().Type.TypeKind); 1819Assert.Equal(TypeKind.TypeParameter, ((IMethodSymbol)candidate.OriginalDefinition).Parameters.Last().Type.TypeKind); 5486Assert.Equal("System.Threading.Tasks.Task<System.Collections.Generic.IEnumerable<System.Threading.Tasks.Task<Program.A>>>", parameterSymbol.Type.ToTestDisplayString());

Compilation\SemanticModelAPITests.cs (2)

2615Assert.Equal("Int32", paramSymbol.Type.Name); 3134Assert.Equal(TypeKind.Error, ((IParameterSymbol)symbol).Type.TypeKind);

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (10)

984Assert.Equal("St", mSymbol.Parameters[0].Type.Name); 985Assert.Equal<ISymbol>(structSymbol, mSymbol.Parameters[1].Type.OriginalDefinition); 1335var names = model.LookupNames(methodDecl.SpanStart, paramSymbol.Type); 1347names = model.LookupNames(methodDecl.SpanStart, paramSymbol.Type); 1438var symbols = model.LookupSymbols(methodDecl.SpanStart, paramSymbol.Type); 1452symbols = model.LookupSymbols(methodDecl.SpanStart, paramSymbol.Type); 1877var typeA = ((IParameterSymbol)symbols[0]).Type; 1881var typeB = ((IParameterSymbol)symbols[0]).Type; 2014var type = ((IParameterSymbol)symbols[0]).Type; 3674Assert.Equal(SpecialType.System_Int32, parameter.Type.SpecialType);

Compilation\SemanticModelGetSemanticInfoTests.cs (4)

5668Assert.Equal("System.String", lambdaSym.Parameters[0].Type.ToTestDisplayString()); 5704Assert.Equal(TypeKind.Error, lambdaSym.Parameters[0].Type.TypeKind); 6344Assert.Equal(TypeKind.Error, param.Type.TypeKind); 6348Assert.NotEqual(semanticInfo.Type, param.Type);

Compilation\SymbolVisitorTests.cs (3)

147symbol.Type.Accept(this); 329symbol.Type.Accept(this); 468symbol.Type.Accept(this, argument);

Symbols\ConversionTests.cs (2)

2146Assert.Equal(SpecialType.System_Byte, method.Parameters.Single().Type.SpecialType); 2180Assert.Equal(SpecialType.System_Byte, method.Parameters.Single().Type.SpecialType);

Symbols\Source\EventTests.cs (2)

443Assert.Equal("dynamic", parameterSymbol.Type.ToTestDisplayString()); 489Assert.Equal("dynamic", parameterSymbol.Type.ToTestDisplayString());

Symbols\Source\MethodTests.cs (2)

123Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 124Assert.Equal("Int32", x.Type.Name); // fully qualified to work around a metadata reader bug

Symbols\Source\NullablePublicAPITests.cs (24)

Symbols\SymbolEqualityTests.cs (2)

846var method1ParamType = method1.Parameters.First().Type; // A<T!> 847var method2ParamType = method2.Parameters.First().Type; // A<T!>

Symbols\TypeTests.cs (3)

1703memType = paras[0].Type; 1706memType = paras[1].Type; 1721var compType = (model.GetDeclaredSymbol(mnode) as IMethodSymbol).Parameters[0].Type;

Symbols\UnsignedRightShiftTests.cs (16)

Extensions.cs (6)

185return type.InstanceConstructors.Single(c => c.Parameters is [{ Type: var parameterType }] && parameterType.Equals(type, SymbolEqualityComparer.Default)); 203return type.GetMembers("Equals").OfType<IMethodSymbol>().Single(m => m.Parameters is [{ Type: var parameterType }] && parameterType.Equals(type, SymbolEqualityComparer.Default)); 216m.Parameters.All(p => p.RefKind == RefKind.Out && p.Type.Equals(primaryConstructor.Parameters[p.Ordinal].Type, SymbolEqualityComparer.Default))); 699public static ITypeSymbol GetParameterType(this IMethodSymbol method, int index) => method.Parameters[index].Type; 825return ((IParameterSymbol)symbol).Type;

FunctionPointerUtilities.cs (1)

244ITypeSymbol signatureParamType = signature.Parameters[i].Type;

Recommendations\CSharpRecommendationServiceRunner.cs (1)

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

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

Rename\CSharpRenameRewriterLanguageService.cs (1)

771(matchingLocal.IsKind(SymbolKind.Parameter) && ((IParameterSymbol)matchingLocal).Type.IsDelegateType());

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

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

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

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

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

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

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

826expressionType.Equals(method.Parameters[0].Type?.OriginalDefinition))

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

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

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

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

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

71.WithType(parameter.Type.GenerateTypeSyntax()) 113=> ExpressionGenerator.GenerateExpression(generator, parameter.Type, value, canUseFieldReference: true);

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

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

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

781.Select(p => new TypeInferenceInfo(p.Type, p.IsParams)); 794var info = new TypeInferenceInfo(parameter.Type, parameter.IsParams); 1223return CreateResult(parameter.Type);

CodeGeneration\SyntaxGeneratorTests.cs (2)

990m.Name == WellKnownMemberNames.ExplicitConversionName && m.Parameters[0].Type.Equals(gcHandleType)); 998m.Name == WellKnownMemberNames.ImplicitConversionName && m.Parameters[0].Type.Equals(_emptyCompilation.GetSpecialType(SpecialType.System_Byte)));

AbstractTypeParameterChecker.cs (1)

61Visit(symbol.Type);

InstructionDecoder.cs (1)

51builder.Append(parameter.Type.ToDisplayString(DisplayFormat));

ChangeSignature\AbstractChangeSignatureService.cs (1)

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

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

109IParameterSymbol parameterSymbol => parameterSymbol.Type,

Completion\Providers\ImportCompletionProvider\ExtensionMethodImportCompletionHelper.SymbolComputer.cs (2)

407if (filterReceiverTypeName.Length > 0 && !string.Equals(filterReceiverTypeName, GetReceiverTypeName(method.Parameters[0].Type), StringComparison.Ordinal)) 412receiverType = method.Parameters[0].Type;

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (1)

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

EditAndContinue\Utilities\Extensions.cs (1)

176=> symbol is IMethodSymbol { Parameters: [var parameter] } && SymbolEqualityComparer.Default.Equals(parameter.Type, symbol.ContainingType);

EmbeddedLanguages\EmbeddedLanguageDetector.cs (1)

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

ExtractMethod\MethodExtractor.Analyzer.cs (3)

142&& thisParameterBeingRead.Type is { TypeKind: TypeKind.Struct, IsReadOnly: false }; 631IParameterSymbol parameter => parameter.Type, 838AddTypeParametersToMap(TypeParameterCollector.Collect(parameter.Type), sortedMap);

ExtractMethod\MethodExtractor.TypeParameterCollector.cs (1)

39param.Type.Accept(this);

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (1)

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

GenerateConstructors\AbstractGenerateConstructorsCodeRefactoringProvider.State.cs (4)

108let constructorTypes = c.Parameters.Select(p => p.Type) 109let symbolTypes = parameters.Take(c.Parameters.Length).Select(p => p.Type) 120=> parameters.Select(p => p.Type).SequenceEqual(constructor.Parameters.Select(p => p.Type));

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (2)

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

InitializeParameter\AbstractAddParameterCheckCodeRefactoringProvider.cs (6)

108if (parameter.Type.SpecialType == SpecialType.System_String) 160if (parameter.Type.SpecialType == SpecialType.System_String) 234else if (parameter.Type.SpecialType == SpecialType.System_String && 247if (parameter.Type.IsReferenceType) 250if (parameter.Type.NullableAnnotation == NullableAnnotation.Annotated) 253else if (!parameter.Type.IsNullable())

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)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.InlineContext.cs (2)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.MethodParametersInfo.cs (2)

503&& parameterSymbol.Type is IArrayTypeSymbol paramArrayParameter 523return GenerateLiteralExpression(parameterSymbol.Type, parameterSymbol.ExplicitDefaultValue);

IntroduceParameter\IntroduceParameterDocumentRewriter.cs (1)

605!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); 136.Select(p => p.Type.ToMinimalDisplayString(semanticModel, position))

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

21methodSymbol.Parameters[0].Type.Equals(_serializationInfoType) && 22methodSymbol.Parameters[1].Type.Equals(_streamingContextType) &&

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

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

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

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

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\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\Analyzers\Core\Analyzers\SimplifyLinqExpression\AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs (1)

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

src\Analyzers\Core\Analyzers\UseCollectionInitializer\UpdateExpressionState.cs (2)

253useSpread = parameter.Type.Equals(convertedType); 263useSpread = method.GetOriginalUnreducedDefinition() is not IMethodSymbol { IsExtensionMethod: true, Parameters: [_, { Type: ITypeParameterSymbol }] };

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

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

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

153var parameterType = parameters[parameterIndex].Type;

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

497compilation, argumentTypeInfo, parameter.Type, 522if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)

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

201[parameter.Type],

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

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

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

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

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

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

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

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

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

221Equals(parameter.Type, cancellationTokenType))

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementHelpers.cs (1)

154if (IsTypeLessAccessibleThanOtherType(parameter.Type, second, []))

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

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

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

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

StackTraceExplorer\AbstractStackTraceSymbolResolver.cs (1)

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

Compilation\TestOperationVisitor.cs (3)

815semanticModel.Compilation.CreateBuiltinOperator(symbol.Name, method.ReturnType, method.Parameters[0].Type); 818semanticModel.Compilation.CreateBuiltinOperator(symbol.Name, method.ReturnType, method.Parameters[0].Type, method.Parameters[1].Type);

Diagnostics\CouldHaveMoreSpecificTypeAnalyzer.cs (1)

92AssignTo(argument.Value, localsSourceTypes, fieldsSourceTypes, argument.Parameter.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\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (5)

43If parameter.Type.IsArrayType() Then 44Dim arrayType = DirectCast(parameter.Type, IArrayTypeSymbol) 62Dim asClause = If(parameter.Type Is Nothing, 64SyntaxFactory.SimpleAsClause(type:=parameter.Type.GenerateTypeSyntax())) 96parameter.Type,

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

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

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

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

Completion\CompletionProviders\EnumCompletionProvider.vb (1)

93If(TryCast(symbol, IParameterSymbol)?.Type,

ExtractMethod\VisualBasicMethodExtractor.VisualBasicCodeGenerator.vb (1)

374Return method.Parameters(0).Type.SpecialType = SpecialType.System_Boolean

IntroduceParameter\VisualBasicIntroduceParameterCodeRefactoringProvider.vb (1)

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

SignatureHelp\FunctionAggregationSignatureHelpProvider.vb (2)

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

SignatureHelp\ObjectCreationExpressionSignatureHelpProvider.DelegateType.vb (1)

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

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (13)

Semantics\NativeIntegerTests.vb (8)

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\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\SemanticModelExtensions.vb (1)

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

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

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

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\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\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\ParameterGenerator.vb (5)

43If parameter.Type.IsArrayType() Then 44Dim arrayType = DirectCast(parameter.Type, IArrayTypeSymbol) 62Dim asClause = If(parameter.Type Is Nothing, 64SyntaxFactory.SimpleAsClause(type:=parameter.Type.GenerateTypeSyntax())) 96parameter.Type,

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

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

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

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

Editing\SyntaxGenerator.cs (3)

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

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); 229builder.Add(parameters[ordinalInLambda].Type); 242parameterType = method.Parameters.FirstOrDefault(p => _stringComparerForLanguage.Equals(p.Name, argumentName))?.Type; 249if (method.Parameters.LastOrDefault()?.Type is IArrayTypeSymbol arrayType) 263parameterType = method.Parameters[ordinalInInvocation].Type; 415if (originalMember is IMethodSymbol { Parameters: [{ Type: ITypeParameterSymbol parameterType }, ..] })

Rename\ConflictEngine\DeclarationConflictHelpers.cs (1)

111signatureBuilder.Add(parameter.Type);

Shared\Extensions\IMethodSymbolExtensions.cs (4)

48if (!invoke.Parameters[i].Type.InheritsFromOrEquals(method.Parameters[i].Type)) 87return p1.Select(p => p.Type).ToList().AreMoreSpecificThan(p2.Select(p => p.Type).ToList());

Shared\Extensions\ISymbolExtensions.cs (2)

529if (!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\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\IMethodSymbolExtensions.cs (2)

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

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

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

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

344IParameterSymbol parameterSymbol => parameterSymbol.Type, 412return ((IParameterSymbol)symbol).Type; 512.Select(p => (p.Type ?? compilation.GetSpecialType(SpecialType.System_Object)).WithNullableAnnotation(p.NullableAnnotation)); 630IParameterSymbol parameterSymbol => parameterSymbol.Type, 697if (!methods.Any(x => x.Name == WellKnownMemberNames.OnCompleted && x.ReturnsVoid && x.Parameters is [{ Type.TypeKind: TypeKind.Delegate }]))

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

126return symbol.Type.Accept(this);

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\ITypeSymbolExtensions.CollectTypeParameterSymbolsVisitor.cs (1)

46parameter.Type.Accept(this);

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

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

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

37/// the "same" <see cref="IParameterSymbol.Type"/>s and 61/// the "same" <see cref="IParameterSymbol.Type"/>s and

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

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

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

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.EquivalenceVisitor.cs (2)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

228GetHashCode(x.Type,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SymbolEquivalenceComparer.ParameterSymbolEqualityComparer.cs (3)

50symbolEqualityComparer.SignatureTypeEquivalenceComparer.Equals(x.Type, y.Type, equivalentTypesWithDifferingAssemblies); 68symbolEqualityComparer.SignatureTypeEquivalenceComparer.GetHashCode(x.Type));

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

306type ?? parameter.Type,

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

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

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

30parameter.Type, 45parameter.Type,

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

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

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

305type: parameter.Type, 327type: parameter.Type, 359var parameterType = parameter.Type; 408var shouldAddNullCheck = addNullChecks && parameter.Type.CanAddNullCheck() && !parameter.Type.IsNullable();

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SyntaxGeneratorInternalExtensions\SyntaxGeneratorInternal.cs (1)

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\TypeInferenceService\AbstractTypeInferenceService.AbstractTypeInferrer.cs (2)

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

SymbolKeyTests.cs (2)

1038Assert.True(method.Parameters[0].Type.IsTupleType); 1075Assert.True(method.Parameters[0].Type.IsTupleType);

UtilityTest\DocumentationCommentIdTests.cs (2)

216CheckDeclarationId<IMethodSymbol>("M:Acme.ValueType.M(System.Int32)", compilation, s => s.Name == "M" && s.Parameters is [{ Type.Name: "Int32" }]); 217CheckDeclarationId<IMethodSymbol>("M:Acme.Widget.NestedClass.M(System.Int32)", compilation, s => s.Name == "M" && s.Parameters is [{ Type.Name: "Int32" }]);

Analyzers\AppContextDefaultsAnalyzer.cs (2)

147if (methodSym.Parameters[0].Type.SpecialType != SpecialType.System_String) 150if (methodSym.Parameters[1].Type.SpecialType != SpecialType.System_Boolean)

LoggerMessageGenerator.Parser.cs (2)

355ITypeSymbol paramTypeSymbol = paramSymbol.Type; 694if (IsBaseOrIdentity(parameter.Type, loggerSymbol))

Parser.cs (4)

204&& m.Parameters[0].Type.SpecialType == SpecialType.System_String 205&& SymbolEqualityComparer.Default.Equals(m.Parameters[1].Type, modelType)); 622if (constructorParameters.Length == 1 && constructorParameters[0].Name == "otherProperty" && constructorParameters[0].Type.SpecialType == SpecialType.System_String) 646argumentType = constructorParameters[0].Type;

Parser.cs (3)