TypeArguments

8 implementations of TypeArguments

GenerateDocumentationAndConfigFiles (1)

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

84public abstract ImmutableArray<ITypeSymbol> TypeArguments { get; }

Microsoft.CodeAnalysis.Analyzers (1)

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

84public abstract ImmutableArray<ITypeSymbol> TypeArguments { get; }

Microsoft.CodeAnalysis.CodeStyle.Fixes (1)

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

84public abstract ImmutableArray<ITypeSymbol> TypeArguments { get; }

Microsoft.CodeAnalysis.CSharp (1)

Symbols\PublicModel\NamedTypeSymbol.cs (1)

72ImmutableArray<ITypeSymbol> INamedTypeSymbol.TypeArguments

Microsoft.CodeAnalysis.Features (1)

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (1)

79public ImmutableArray<ITypeSymbol> TypeArguments => _symbol.TypeArguments;

Microsoft.CodeAnalysis.VisualBasic (1)

Symbols\NamedTypeSymbol.vb (1)

1377Private ReadOnly Property INamedTypeSymbol_TypeArguments As ImmutableArray(Of ITypeSymbol) Implements INamedTypeSymbol.TypeArguments

Microsoft.CodeAnalysis.Workspaces (1)

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

84public abstract ImmutableArray<ITypeSymbol> TypeArguments { get; }

Roslyn.Diagnostics.Analyzers (1)

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

84public abstract ImmutableArray<ITypeSymbol> TypeArguments { get; }

641 references to TypeArguments

Aspire.Hosting.Integration.Analyzers (24)

AspireExportAnalyzer.cs (24)

ConfigurationSchemaGenerator (8)

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

225underlyingType = genericType.TypeArguments[0]; 544type = ((INamedTypeSymbol)type).TypeArguments[0]; // extract the T from a Nullable<T> 759elementType = candidate.TypeArguments[0]; 773keyType = candidate.TypeArguments[0]; 774elementType = candidate.TypeArguments[1]; 839foreach (ITypeSymbol typeArg in genericType.TypeArguments)

RuntimeSource\SourceGenerators\TypeModelHelper.cs (2)

31if (!current.TypeArguments.IsEmpty) 33(args ??= new()).AddRange(current.TypeArguments);

GenerateDocumentationAndConfigFiles (34)

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

106var parameters = type.TypeArguments;

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

263=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

210&& namedTypeSymbol.TypeArguments.Length == 1 211&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

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

67elementType = namedType.TypeArguments.Single(); 76elementType = foundType?.TypeArguments.FirstOrDefault() ?? compilation.ObjectType; 170.Select(m => m.Arity == 0 ? m : m.Construct(ImmutableCollectionsMarshal.AsArray(collectionExpressionType.TypeArguments)!))

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

69underlyingType = ((INamedTypeSymbol)symbol).TypeArguments[0]; 424var typeArgument = ((INamedTypeSymbol)typeSymbol).TypeArguments[0]; 787TypeArguments.Length: 1, 795TypeArguments.Length: 1,

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

70return AreEquivalent(array.ElementType, readOnlySpanType.TypeArguments.Single(), equivalentTypesWithDifferingAssemblies); 415TypeArgumentsAreEquivalent(x.TypeArguments, y.TypeArguments, equivalentTypesWithDifferingAssemblies);

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

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

178? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments)

ILLink.RoslynAnalyzer (5)

TrimAnalysis\GenericArgumentDataFlow.cs (2)

45ProcessGenericArgumentDataFlow(type.TypeArguments, type.TypeParameters); 98foreach (var typeArgument in type.TypeArguments)

TrimAnalysis\HandleCallAction.cs (1)

84foreach (var arg in symbol.TypeArguments)

TrimAnalysis\SingleValueExtensions.cs (1)

18var underlyingType = (type as INamedTypeSymbol)?.TypeArguments.FirstOrDefault();

UnsafeMigrationAnalyzerHelpers.cs (1)

146foreach (ITypeSymbol typeArgument in namedType.TypeArguments)

Microsoft.Analyzers.Extra (3)

Arrays.cs (3)

107var keyType = type.TypeArguments[0]; 123if (type.TypeArguments.Length == 2) 125valueType = type.TypeArguments[1];

Microsoft.AspNetCore.App.Analyzers (9)

Http\RequestDelegateReturnTypeAnalyzer.cs (1)

88((INamedTypeSymbol)returnType).TypeArguments[0].ToString()));

RouteHandlers\DisallowNonParsableComplexTypesOnParameters.cs (2)

133parameterTypeSymbol.TypeArguments.Length > 0) 135parameterTypeSymbol = parameterTypeSymbol.TypeArguments[0] as INamedTypeSymbol;

RouteHandlers\DisallowReturningActionResultFromMapMethods.cs (2)

91if (returnType is not INamedTypeSymbol { Name: "Task" or "ValueTask", IsGenericType: true, TypeArguments: { Length: 1 } } taskLike) 96return taskLike.TypeArguments[0];

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

131SymbolEqualityComparer.Default.Equals(constructedTypeSymbol.TypeArguments[0].UnwrapTypeSymbol(unwrapNullable: true), typeSymbol); 158SymbolEqualityComparer.Default.Equals(returnType.TypeArguments[0].UnwrapTypeSymbol(unwrapNullable: true), containingType);

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

36unwrappedTypeSymbol = unwrappedTypeSymbol.TypeArguments[0] as INamedTypeSymbol; 320var underlyingType = namedType.TypeArguments.FirstOrDefault();

Microsoft.AspNetCore.Components.AI.SourceGenerators (2)

ToolBlockParser.cs (2)

263&& namedType.TypeArguments.Length == 1) 265type = namedType.TypeArguments[0];

Microsoft.AspNetCore.Http.RequestDelegateGenerator (8)

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

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

36unwrappedTypeSymbol = unwrappedTypeSymbol.TypeArguments[0] as INamedTypeSymbol; 320var underlyingType = namedType.TypeArguments.FirstOrDefault();

StaticRouteHandlerModel\Emitters\DiagnosticEmitter.cs (2)

41((INamedTypeSymbol)typeSymbol).TypeArguments.Any(a => a is ITypeParameterSymbol)) 48((INamedTypeSymbol)typeSymbol).TypeArguments.Any(typeArg =>

StaticRouteHandlerModel\EndpointResponse.cs (1)

58return ((INamedTypeSymbol)returnType).TypeArguments[0];

StaticRouteHandlerModel\Model\EndpointParameterExtensions.cs (1)

55=> ((INamedTypeSymbol?)parameter.BindableMethodSymbol?.ReturnType)?.TypeArguments[0];

Microsoft.AspNetCore.OpenApi.SourceGenerators (1)

Helpers\ISymbolExtensions.cs (1)

91INamedTypeSymbol nt => nt.TypeArguments,

Microsoft.AspNetCore.SignalR.Client.SourceGenerator (4)

HubServerProxyGenerator.Parser.cs (4)

280methodSpec.InnerReturnTypeName = rtype.TypeArguments[0].ToString(); 284&& a.TypeArguments[0] is INamedTypeSymbol { Arity: 1, Name: "ChannelReader" } b) 287methodSpec.InnerReturnTypeName = b.TypeArguments[0].ToString(); 292methodSpec.InnerReturnTypeName = c.TypeArguments[0].ToString();

Microsoft.CodeAnalysis (7)

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (1)

566return TypeInfo.Create(containingType.TypeArguments[i]);

DocumentationCommentId.cs (3)

625else if (symbol.TypeArguments.Length > 0) 629for (int i = 0, n = symbol.TypeArguments.Length; i < n; i++) 636this.Visit(symbol.TypeArguments[i]);

Operations\ControlFlowGraphBuilder.cs (1)

3140((INamedTypeSymbol)operation.Target.Type!).TypeArguments[0].Equals(operation.Type))

Symbols\INamedTypeSymbol.cs (1)

92/// The modifiers correspond to the type argument at the same ordinal within the <see cref="TypeArguments"/>

Symbols\ITypeSymbol.cs (1)

252return ((INamedTypeSymbol)type).TypeArguments[0];

Microsoft.CodeAnalysis.Analyzers (39)

MetaAnalyzers\CompareSymbolsCorrectlyAnalyzer.cs (2)

266!createdType.TypeArguments.IsEmpty && 267IsSymbolType(createdType.TypeArguments[0], symbolType) &&

MetaAnalyzers\DiagnosticAnalyzerAPIUsageAnalyzer.cs (1)

275foreach (var typeArgument in usedType.TypeArguments)

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

106var parameters = type.TypeArguments;

src\roslyn\src\RoslynAnalyzers\Microsoft.CodeAnalysis.BannedApiAnalyzers\Core\SymbolIsBannedAnalyzerBase.cs (1)

389foreach (var typeArgument in namedTypeSymbol.TypeArguments)

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

362foreach (var type in usedType.TypeArguments)

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

263=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

210&& namedTypeSymbol.TypeArguments.Length == 1 211&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

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

178? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments)

Microsoft.CodeAnalysis.AnalyzerUtilities (33)

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

362foreach (var type in usedType.TypeArguments)

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

263=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

210&& namedTypeSymbol.TypeArguments.Length == 1 211&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

Microsoft.CodeAnalysis.CodeStyle (32)

src\roslyn\src\Analyzers\Core\Analyzers\ConvertTypeofToNameof\AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

72return namedType.TypeArguments.Length == 0;

src\roslyn\src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

103collectionElementType = ienumerableOfT.TypeArguments[0];

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

566return TypeInfo.Create(containingType.TypeArguments[i]);

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

Microsoft.CodeAnalysis.CodeStyle.Fixes (4)

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

106var parameters = type.TypeArguments;

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

50foreach (var typeArg in symbol.TypeArguments)

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

201foreach (var genericParam in namedType.TypeArguments)

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

178? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments)

Microsoft.CodeAnalysis.CSharp (4)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (4)

230var typeArg = symbol.TypeArguments[0]; 442AddTypeParameterConstraints(symbol.TypeArguments); 544tupleSymbol = (INamedTypeSymbol)currentUnderlying.TypeArguments[NamedTypeSymbol.ValueTupleRestPosition - 1]; 835typeArguments = ((INamedTypeSymbol)owner).TypeArguments;

Microsoft.CodeAnalysis.CSharp.CodeStyle (9)

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

109semanticModel.Compilation, ienumerableType.TypeArguments.Single()))

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

950TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }] 997TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }]

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

156containingType.TypeArguments.Length == 0 &&

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

1049return iface.TypeArguments.Single();

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

676if (namedCastedType.TypeArguments.Length != 1 && originalNamedConvertedType.TypeArguments.Length != 1) 679if (!originalNamedConvertedType.TypeArguments[0].Equals(namedCastedType.TypeArguments[0], SymbolEqualityComparer.IncludeNullability))

Microsoft.CodeAnalysis.CSharp.CodeStyle.Fixes (15)

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

66namedType.TypeArguments[0].SpecialType == SpecialType.System_Byte;

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

204? Enumerable.Repeat((TypeSyntax)OmittedTypeArgument(), symbol.TypeArguments.Length) 205: symbol.TypeArguments.SelectAsArray(t => t.GenerateTypeSyntax()); 233var innerType = symbol.TypeArguments.First();

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

55var constructedListType = listOfTType.Construct(collectionExpressionType.TypeArguments.Single());

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

710if (inferredNamedType.TypeArguments.Length == returnNamedType.TypeArguments.Length) 712for (int i = 0, n = inferredNamedType.TypeArguments.Length; i < n; i++) 714DetermineTypeParameterMapping(inferredNamedType.TypeArguments[i], returnNamedType.TypeArguments[i], result); 1841var typeArg = delegateType?.TypeArguments.Length > 0 1842? delegateType.TypeArguments[0] 2072return memberType is INamedTypeSymbol namedType && namedType.TypeArguments.Length == 1 2073? [new TypeInferenceInfo(namedType.TypeArguments[0])] 2087return namedTypeSymbol.TypeArguments[0];

Microsoft.CodeAnalysis.CSharp.Features (11)

Completion\CompletionProviders\CSharpSuggestionModeCompletionProvider.cs (1)

201typeSymbol = ienumerableType.TypeArguments.Single();

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

78if (originalType is INamedTypeSymbol { Name: "Func", ContainingNamespace.Name: "System", TypeArguments: [.., var returnType] }) 145if (type is IErrorTypeSymbol { TypeArguments: [var typeArgument] } && 165Equals(t.OriginalDefinition, compilation.IAsyncEnumerableOfTType()))?.TypeArguments[0]; 190return UnwrapType(namedType.TypeArguments[0], compilation, wasPlural: wasPlural, seenTypes: seenTypes);

QuickInfo\CSharpSemanticQuickInfoProvider.cs (1)

177builder.AddRange(type.TypeArguments);

SignatureHelp\AbstractGenericNameSignatureHelpProvider.cs (1)

168result.AddRange(method.ContainingType.TypeArguments.Select(t => new SignatureHelpSymbolParameter(

src\roslyn\src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForArrayDiagnosticAnalyzer.cs (1)

109semanticModel.Compilation, ienumerableType.TypeArguments.Single()))

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

950TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }] 997TypeArguments: [ITypeParameterSymbol { TypeParameterKind: TypeParameterKind.Method }]

src\roslyn\src\Analyzers\CSharp\CodeFixes\UseUtf8StringLiteral\UseUtf8StringLiteralCodeFixProvider.cs (1)

66namedType.TypeArguments[0].SpecialType == SpecialType.System_Byte;

Microsoft.CodeAnalysis.CSharp.NetAnalyzers (4)

Microsoft.CodeQuality.Analyzers\Maintainability\CSharpAvoidUninstantiatedInternalClasses.cs (1)

29var generics = namedTypeSymbol.TypeParameters.Zip(namedTypeSymbol.TypeArguments, (parameter, argument) => (parameter, argument));

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

94if (namedType.TypeArguments is [var typeArgument])

Microsoft.NetCore.Analyzers\Runtime\CSharpForwardCancellationTokenToInvocationsFixer.TypeNameVisitor.cs (2)

142? Enumerable.Repeat((TypeSyntax)OmittedTypeArgument(), symbol.TypeArguments.Length) 143: symbol.TypeArguments.Select(GetTypeSyntaxForSymbol);

Microsoft.CodeAnalysis.CSharp.Workspaces (24)

Simplification\CSharpSimplificationService.Expander.cs (2)

836if (namedTypedSymbol.TypeArguments.Length != 0) 838foreach (var typeArgument in namedTypedSymbol.TypeArguments)

Simplification\Simplifiers\ExpressionSimplifier.cs (1)

424if (rightSymbol.ContainingType is { TypeArguments.Length: 0 } containingType &&

Simplification\Simplifiers\NameSimplifier.cs (1)

442var argument = type.TypeArguments.SingleOrDefault();

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

156containingType.TypeArguments.Length == 0 &&

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

1049return iface.TypeArguments.Single();

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

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

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

55var constructedListType = listOfTType.Construct(collectionExpressionType.TypeArguments.Single());

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

Microsoft.CodeAnalysis.Extensions.Package (21)

Symbols\INamedTypeSymbolExtensions.cs (2)

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

Symbols\ISymbolExtensions_Accessibility.cs (1)

191foreach (var typeArg in type.TypeArguments)

Symbols\ISymbolExtensions.cs (1)

456INamedTypeSymbol nt => nt.TypeArguments,

Symbols\ITypeSymbolExtensions.AnonymousTypeRemover.cs (2)

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.cs (4)

Symbols\ITypeSymbolExtensions.MinimalAccessibilityVisitor.cs (1)

54foreach (var arg in symbol.TypeArguments)

Symbols\ITypeSymbolExtensions.SubstituteTypesVisitor.cs (2)

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

Symbols\ITypeSymbolExtensions.UnavailableTypeParameterRemover.cs (2)

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\ITypeSymbolExtensions.UnnamedErrorTypeRemover.cs (2)

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (3)

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

Microsoft.CodeAnalysis.Features (16)

ConvertForToForEach\AbstractConvertForToForEachCodeRefactoringProvider.cs (3)

274iterationType = instantiatedIEnumerableType.TypeArguments[0]; 303iterationType = instantiatedIEnumeratorType.TypeArguments[0]; 529return interfaceType.TypeArguments[0];

Debugging\AbstractBreakpointResolver.cs (1)

166(nameAndArity.Arity == 0 || nameAndArity.Arity == typeSymbol.TypeArguments.Length);

FullyQualify\AbstractFullyQualifyService.cs (1)

238if (looksGeneric && searchResult.TypeArguments.Length == 0)

GenerateComparisonOperators\GenerateComparisonOperatorsCodeRefactoringProvider.cs (3)

75var comparedType = iface.TypeArguments[0]; 106var typeArg = missingType.TypeArguments[0]; 182var comparedType = comparableType.TypeArguments[0];

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (1)

79public ImmutableArray<ITypeSymbol> TypeArguments => _symbol.TypeArguments;

QuickInfo\CommonSemanticQuickInfoProvider.ErrorVisitor.cs (1)

61foreach (var typeParameter in symbol.TypeArguments.Concat(symbol.TypeParameters))

RQName\RQNodeBuilder.cs (1)

324foreach (var typeArgument in entry.TypeArguments)

src\roslyn\src\Analyzers\Core\Analyzers\ConvertTypeofToNameof\AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs (1)

72return namedType.TypeArguments.Length == 0;

src\roslyn\src\Analyzers\Core\Analyzers\ForEachCast\AbstractForEachCastDiagnosticAnalyzer.cs (1)

103collectionElementType = ienumerableOfT.TypeArguments[0];

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

50foreach (var typeArg in symbol.TypeArguments)

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

201foreach (var genericParam in namedType.TypeArguments)

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

566return TypeInfo.Create(containingType.TypeArguments[i]);

Microsoft.CodeAnalysis.NetAnalyzers (38)

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

142var generics = constructedClass.TypeParameters.Zip(constructedClass.TypeArguments, (parameter, argument) => (parameter, argument)); 395var newGenerics = namedTypeArg.TypeParameters.Zip(namedTypeArg.TypeArguments, (parameter, argument) => (parameter, argument));

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

314((supportedTypes.Length == 0) || supportedTypes.Contains(namedReturnTypeSymbol.TypeArguments[0].SpecialType)) && 333((supportedTypes.Length == 0) || supportedTypes.Contains(namedReturnTypeSymbol.TypeArguments[0].SpecialType)) && 351((supportedTypes.Length == 0) || supportedTypes.Contains(namedReturnTypeSymbol.TypeArguments[0].SpecialType)) &&

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

1380CheckTypeArguments(namedType.TypeArguments); 1401CheckTypeArgumentsCore(nType.TypeArguments, workingSet);

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

274return readOnlyCounterpart.Construct(instanceType.TypeArguments.ToArray()) 432if (namedType.TypeArguments.Length is 1) 434readOnlyType = readOnlySpan.Construct(namedType.TypeArguments[0]); 440if (namedType.TypeArguments.Length is 1) 442readOnlyType = readOnlyMemory.Construct(namedType.TypeArguments[0]);

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

74if (parameterType.TypeArguments.Length != 1) 92var newTypeNode = editor.Generator.TypeExpression(readOnlyType.Construct(parameterType.TypeArguments[0]));

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

277for (int i = 0; i < tupleType.TypeArguments.Length; i++) 279var valueType = tupleType.TypeArguments[i];

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

258namedType.TypeArguments is [var typeArgument] &&

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

104parameterType.TypeArguments is [var typeArgument] &&

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

304ISymbol? previewSymbol = GetPreviewSymbolForGenericTypesFromTypeArguments(innerNamedType.TypeArguments, requiresPreviewFeaturesSymbols, previewFeatureAttributeSymbol); 467ISymbol? previewTypeArgument = GetPreviewSymbolForGenericTypesFromTypeArguments(typeSymbol.TypeArguments, requiresPreviewFeaturesSymbols, previewFeatureAttribute); 596ISymbol? innerPreviewSymbol = GetPreviewSymbolForGenericTypesFromTypeArguments(typeSymbol.TypeArguments, requiresPreviewFeaturesSymbols, previewFeatureAttributeSymbol);

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

104|| !argIEnumerableType.TypeArguments.HasExactly(1)) 109return argIEnumerableType.TypeArguments[0];

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

437var leftTypeArgument = left.TypeArguments[0]; 438var rightTypeArgument = right.TypeArguments[0];

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

127ITypeSymbol keyType = constructedDictionaryType.TypeArguments[0]; 128ITypeSymbol valueType = constructedDictionaryType.TypeArguments[1];

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

117foreach (var arg in namedTypeSymbol.TypeArguments)

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

430foreach (ITypeSymbol? arg in namedTypeSymbol.TypeArguments)

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

152foreach (var arg in namedTypeSymbol.TypeArguments)

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

126namedTypeSymbol.TypeArguments.Length == 1 && 127namedTypeSymbol.TypeArguments.Contains(sharedAccessProtocolTypeSymbol));

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

151anInterface.TypeArguments[0].Name != symbol.Name;

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

363foreach (var type in usedType.TypeArguments)

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\ITypeSymbolExtensions.cs (2)

317=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean; 320=> typeSymbol.IsNullableValueType() ? ((INamedTypeSymbol)typeSymbol).TypeArguments[0] : null;

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\WellKnownTypeProvider.cs (2)

264&& namedTypeSymbol.TypeArguments.Length == 1 265&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

Microsoft.CodeAnalysis.Razor.Compiler (10)

CSharp\DefaultTagHelperDescriptorFactory.cs (2)

319return propertyType.TypeArguments; 325var result = dictionaryType?.TypeArguments ?? [];

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

166foreach (var typeArgument in type.TypeArguments) 356foreach (var typeArgument in namedType.TypeArguments)

Mvc.Version1_X\ViewComponentTagHelperDescriptorFactory.cs (2)

228if (dictionaryType == null || dictionaryType.TypeArguments[0].SpecialType != SpecialType.System_String) 233var type = dictionaryType.TypeArguments[1];

Mvc.Version2_X\ViewComponentTagHelperDescriptorFactory.cs (2)

243if (dictionaryType == null || dictionaryType.TypeArguments[0].SpecialType != SpecialType.System_String) 248var type = dictionaryType.TypeArguments[1];

Mvc\ViewComponentTagHelperDescriptorFactory.cs (2)

246if (dictionaryType == null || dictionaryType.TypeArguments[0].SpecialType != SpecialType.System_String) 251var type = dictionaryType.TypeArguments[1];

Microsoft.CodeAnalysis.ResxSourceGenerator (33)

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

362foreach (var type in usedType.TypeArguments)

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

263=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

210&& namedTypeSymbol.TypeArguments.Length == 1 211&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

Microsoft.CodeAnalysis.VisualBasic (4)

SymbolDisplay\SymbolDisplayVisitor.Types.vb (3)

101symbol.TypeArguments(0).Accept(Me.NotFirstVisitor()) 304AddTypeArguments(symbol.TypeArguments, symbol) 361tupleSymbol = DirectCast(currentUnderlying.TypeArguments(TupleTypeSymbol.RestPosition - 1), INamedTypeSymbol)

Symbols\NamedTypeSymbol.vb (1)

1377Private ReadOnly Property INamedTypeSymbol_TypeArguments As ImmutableArray(Of ITypeSymbol) Implements INamedTypeSymbol.TypeArguments

Microsoft.CodeAnalysis.VisualBasic.CodeStyle.Fixes (5)

src\f736901a33c2b55b\VisualBasicTypeInferenceService.TypeInferrer.vb (2)

512Return New TypeInferenceInfo(DirectCast(t.InferredType, INamedTypeSymbol).TypeArguments(0)) 776Return CreateResult(DirectCast(memberType, INamedTypeSymbol).TypeArguments(0))

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

48Return GenerateExpression(generator, DirectCast(type, INamedTypeSymbol).TypeArguments(0), value, canUseFieldReference)

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

82Return AddInformationTo(SyntaxFactory.NullableType(symbol.TypeArguments.First().Accept(Me)), symbol) 91SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(symbol.TypeArguments.[Select](Function(t) t.Accept(Me)))))

Microsoft.CodeAnalysis.VisualBasic.NetAnalyzers (3)

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

265Return type.TypeArguments(1)

Microsoft.NetCore.Analyzers\Runtime\BasicForwardCancellationTokenToInvocationsFixer.TypeNameVisitor.vb (2)

118Return AddInformationTo(SyntaxFactory.NullableType(symbol.TypeArguments.First().Accept(New TypeNameVisitor()))) 127SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList(symbol.TypeArguments.[Select](Function(t) t.Accept(New TypeNameVisitor())))))

Microsoft.CodeAnalysis.VisualBasic.Workspaces (7)

Simplification\Simplifiers\ExpressionSimplifier.vb (1)

254containingType.TypeArguments.Length <> 0 Then

Simplification\Simplifiers\NameSimplifier.vb (1)

445Dim argument = type.TypeArguments.SingleOrDefault()

src\f736901a33c2b55b\VisualBasicTypeInferenceService.TypeInferrer.vb (2)

512Return New TypeInferenceInfo(DirectCast(t.InferredType, INamedTypeSymbol).TypeArguments(0)) 776Return CreateResult(DirectCast(memberType, INamedTypeSymbol).TypeArguments(0))

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

48Return GenerateExpression(generator, DirectCast(type, INamedTypeSymbol).TypeArguments(0), value, canUseFieldReference)

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

Microsoft.CodeAnalysis.Workspaces (32)

ObsoleteSymbol\AbstractObsoleteSymbolService.cs (1)

200if (symbol is INamedTypeSymbol { OriginalDefinition.SpecialType: SpecialType.System_Nullable_T, TypeArguments: [var valueType] })

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

106var parameters = type.TypeArguments;

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

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

178? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments)

Microsoft.Diagnostics.DataContractReader.DataGenerator (3)

Parser.cs (3)

406type = named.TypeArguments[0]; 445named.TypeArguments.Length == 1) 447type = named.TypeArguments[0];

Microsoft.Extensions.Configuration.Binder.SourceGeneration (9)

ConfigurationBindingGenerator.Parser.cs (7)

229underlyingType = genericType.TypeArguments[0]; 569type = ((INamedTypeSymbol)type).TypeArguments[0]; // extract the T from a Nullable<T> 851elementType = candidate.TypeArguments[0]; 865keyType = candidate.TypeArguments[0]; 866elementType = candidate.TypeArguments[1]; 943foreach (ITypeSymbol typeArgument in genericType.TypeArguments) 969foreach (ITypeSymbol typeArg in genericType.TypeArguments)

src\runtime\src\libraries\Common\src\SourceGenerators\TypeModelHelper.cs (2)

31if (!current.TypeArguments.IsEmpty) 33(args ??= new()).AddRange(current.TypeArguments);

Microsoft.Extensions.Options.SourceGeneration (13)

Parser.cs (12)

296&& impl.ContainingType.TypeArguments.Length == 1 297&& SymbolEqualityComparer.Default.Equals(impl.ContainingType.TypeArguments[0], modelType)); 326foreach (var ta in mt.TypeArguments) 355type = ((INamedTypeSymbol)type).TypeArguments[0]; 361return ((INamedTypeSymbol)type).TypeArguments[0]; 369return implementingInterface.TypeArguments.First(); 383modelType = ((INamedTypeSymbol)modelType).TypeArguments[0]; 765typeSymbol = ((INamedTypeSymbol)typeSymbol).TypeArguments[0]; 817mt = ((INamedTypeSymbol)mt).TypeArguments[0]; 936&& SymbolEqualityComparer.Default.Equals(implementingInterface.TypeArguments.First(), modelType)) 952result.Add(implementingInterface.TypeArguments.First()); 965var t = implementingInterface.TypeArguments.First();

ParserUtilities.cs (1)

78type = ((INamedTypeSymbol)type).TypeArguments[0]; // extract the T from a Nullable<T>

Microsoft.Extensions.Validation.ValidationsGenerator (9)

Extensions\ITypeSymbolExtensions.cs (5)

31if (type.TypeArguments.Length != 1) 38elementType = type.TypeArguments[0]; 48elementType = type.TypeArguments[0]; 74type is INamedTypeSymbol { TypeArguments.Length: 1 }) 77type = ((INamedTypeSymbol)type).TypeArguments[0];

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

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

36unwrappedTypeSymbol = unwrappedTypeSymbol.TypeArguments[0] as INamedTypeSymbol; 320var underlyingType = namedType.TypeArguments.FirstOrDefault();

Microsoft.Gen.Logging (7)

Parser.cs (1)

643extractedType = ((INamedTypeSymbol)paramTypeSymbol).TypeArguments[0];

Parser.LogProperties.cs (4)

45paramTypeSymbol = ((INamedTypeSymbol)paramTypeSymbol).TypeArguments[0]; 186extractedType = ((INamedTypeSymbol)extractedType).TypeArguments[0]; 273extractedType = ((INamedTypeSymbol)extractedType).TypeArguments[0]; 343symType = ((INamedTypeSymbol)symType).TypeArguments[0];

Parser.Records.cs (1)

129extractedType = ((INamedTypeSymbol)memberType).TypeArguments[0];

TypeSymbolExtensions.cs (1)

97return namedTypeSymbol.TypeArguments[0];

Microsoft.Gen.MetadataExtractor (2)

Parser_2.cs (2)

214=> symbol.TypeArguments.IsDefaultOrEmpty 216: symbol.TypeArguments[0];

Microsoft.Gen.Metrics (2)

Parser.cs (2)

214=> symbol.TypeArguments.IsDefaultOrEmpty 216: symbol.TypeArguments[0];

Microsoft.Gen.MetricsReports (2)

Parser.cs (2)

214=> symbol.TypeArguments.IsDefaultOrEmpty 216: symbol.TypeArguments[0];

Microsoft.Interop.ComInterfaceGenerator (1)

VtableIndexStubGenerator.cs (1)

366var unwrapperSyntax = ParseTypeName(unmanagedObjectUnwrapper.AttributeClass.TypeArguments[0].ToDisplayString());

Microsoft.Interop.JavaScript.JSImportGenerator (11)

JSManagedTypeInfo.cs (9)

103if (CreateJSTypeInfoForTypeSymbol(nullable.TypeArguments[0]) is JSSimpleTypeInfo uti) 120case INamedTypeSymbol { TypeArguments.Length: 1 } taskType when fullTypeName.StartsWith(Constants.TaskGlobal, StringComparison.Ordinal): 121if (CreateJSTypeInfoForTypeSymbol(taskType.TypeArguments[0]) is JSSimpleTypeInfo rti) 128case INamedTypeSymbol { TypeArguments.Length: 1 } spanType when fullTypeName.StartsWith(Constants.SpanGlobal, StringComparison.Ordinal): 129if (CreateJSTypeInfoForTypeSymbol(spanType.TypeArguments[0]) is JSSimpleTypeInfo sti) 136case INamedTypeSymbol { TypeArguments.Length: 1 } arraySegmentType when fullTypeName.StartsWith(Constants.ArraySegmentGlobal, StringComparison.Ordinal): 137if (CreateJSTypeInfoForTypeSymbol(arraySegmentType.TypeArguments[0]) is JSSimpleTypeInfo gti) 147var argumentTypes = actionType.TypeArguments 158var signatureTypes = funcType.TypeArguments

JSMarshalAsAttributeInfoParser.cs (2)

26INamedTypeSymbol? jsTypeArgs = attributeData.AttributeClass.TypeArguments[0] as INamedTypeSymbol; 35foreach (var ta in jsTypeArgs.TypeArguments.Cast<INamedTypeSymbol>().Select(x => x.ToDisplayString()))

Microsoft.Interop.LibraryImportGenerator (6)

Analyzers\CustomMarshallerAttributeAnalyzer.cs (2)

992allocatedBufferType.TypeArguments[0].ToDisplayString()); 1000elementType = ((INamedTypeSymbol)spanTypeMaybe).TypeArguments[0];

Analyzers\CustomMarshallerAttributeFixer.cs (4)

389return ((INamedTypeSymbol)methods.ManagedValuesSource.ReturnType).TypeArguments[0]; 393return ((INamedTypeSymbol)methods.ManagedValuesDestination.ReturnType).TypeArguments[0]; 556return ((INamedTypeSymbol)methods.ManagedValuesSource.ReturnType).TypeArguments[0]; 560return ((INamedTypeSymbol)methods.ManagedValuesDestination.ReturnType).TypeArguments[0];

Microsoft.Interop.SourceGeneration (13)

ArrayMarshallingInfoProvider.cs (1)

70arrayMarshaller.TypeArguments.Last());

CustomMarshallingInfoHelper.cs (1)

56entryPointType.TypeArguments.Last());

ManualTypeMarshallingHelper.cs (7)

385ITypeSymbol resultType = entryType.TypeArguments[0]; 469collectionElementType = ((INamedTypeSymbol)methods.ManagedValuesSource.ReturnType).TypeArguments[0]; 500collectionElementType = ((INamedTypeSymbol)methods.ManagedValuesDestination.ReturnType).TypeArguments[0]; 527bufferElementType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(((INamedTypeSymbol)methods.ToUnmanagedWithBuffer.Parameters[1].Type).TypeArguments[0]); 575collectionElementType = ((INamedTypeSymbol)methods.ManagedValuesSource.ReturnType).TypeArguments[0]; 593collectionElementType = ((INamedTypeSymbol)methods.ManagedValuesDestination.ReturnType).TypeArguments[0]; 607bufferElementType = ManagedTypeInfo.CreateTypeInfoForTypeSymbol(((INamedTypeSymbol)methods.FromManagedWithBuffer.Parameters[1].Type).TypeArguments[0]);

MarshallerShape.cs (3)

228if (!SymbolEqualityComparer.Default.Equals(spanOfT, namedType.ConstructedFrom) || namedType.TypeArguments.Length != 1) 231ITypeSymbol typeArgument = namedType.TypeArguments[0]; 242&& SymbolEqualityComparer.Default.Equals(currentType.TypeArguments[i], typeArgument))

TypeSymbolExtensions.cs (1)

312genericTypesToSubstitute.Push((instantiatedType.TypeArguments, instantiatedType.TypeArgumentNullableAnnotations));

Microsoft.Maui.Controls.BindingSourceGen (1)

ITypeSymbolExtensions.cs (1)

41 return ((INamedTypeSymbol)typeSymbol).TypeArguments[0].ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);

Roslyn.Diagnostics.Analyzers (36)

AbstractDoNotCopyValue.cs (1)

1566var nullableUnderlyingType = ((INamedTypeSymbol)type).TypeArguments.FirstOrDefault();

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

106var parameters = type.TypeArguments;

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

362foreach (var type in usedType.TypeArguments)

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

263=> typeSymbol.IsNullableValueType() && ((INamedTypeSymbol)typeSymbol).TypeArguments[0].SpecialType == SpecialType.System_Boolean;

src\roslyn\src\RoslynAnalyzers\Utilities\Compiler\WellKnownTypeProvider.cs (2)

210&& namedTypeSymbol.TypeArguments.Length == 1 211&& typeArgumentPredicate(namedTypeSymbol.TypeArguments[0]);

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

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

47/// the "same" <see cref="INamedTypeSymbol.TypeArguments"/>.</item>

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

40visitor.WriteSymbolKeyArray(symbol.TypeArguments); 74getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

29symbol.Equals(symbol.ConstructedFrom) || symbol.IsUnboundGenericType ? [] : symbol.TypeArguments); 50getContextualSymbol: static (contextualType, i) => SafeGet(contextualType.TypeArguments, i),

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

53return stack.SelectManyAsArray(n => n.TypeArguments); 706TypeArguments.Length: 1,

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

191foreach (var typeArg in type.TypeArguments)

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

456INamedTypeSymbol nt => nt.TypeArguments,

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

47var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 48if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

54foreach (var arg in symbol.TypeArguments)

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

87var substitutedArguments = symbol.TypeArguments.Select(t => t.Accept(this)); 88if (symbol.TypeArguments.SequenceEqual(substitutedArguments))

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

45var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 46if (arguments.SequenceEqual(symbol.TypeArguments))

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

49var arguments = symbol.TypeArguments.Select(t => t.Accept(this)).ToArray(); 50if (arguments.SequenceEqual(symbol.TypeArguments))

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

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

190: CombineHashCodes(x.TypeArguments, currentHash, _symbolAggregator);

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

178? factory.GenericName(classOrStructType.Name, classOrStructType.TypeArguments)

Roslyn.Diagnostics.CSharp.Analyzers (20)

src\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\CodeStyle\TypeStyle\TypeStyleHelper.cs (1)

156containingType.TypeArguments.Length == 0 &&

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

1049return iface.TypeArguments.Single();

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

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

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

55var constructedListType = listOfTType.Construct(collectionExpressionType.TypeArguments.Single());

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

Roslyn.Diagnostics.VisualBasic.Analyzers (5)

src\f736901a33c2b55b\VisualBasicTypeInferenceService.TypeInferrer.vb (2)

512Return New TypeInferenceInfo(DirectCast(t.InferredType, INamedTypeSymbol).TypeArguments(0)) 776Return CreateResult(DirectCast(memberType, INamedTypeSymbol).TypeArguments(0))

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

48Return GenerateExpression(generator, DirectCast(type, INamedTypeSymbol).TypeArguments(0), value, canUseFieldReference)

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

System.Text.Json.SourceGeneration (50)

Helpers\RoslynExtensions.cs (5)

84ImmutableArray<ITypeSymbol> typeArguments = namedType.TypeArguments; 318ImmutableArray<ITypeSymbol> patternArgs = patternNamed.TypeArguments; 319ImmutableArray<ITypeSymbol> targetArgs = targetNamed.TypeArguments; 370ImmutableArray<ITypeSymbol> args = named.TypeArguments; 615elementType = ((INamedTypeSymbol)type).TypeArguments[0];

JsonSourceGenerator.Parser.cs (43)

src\runtime\src\libraries\Common\src\SourceGenerators\TypeModelHelper.cs (2)

31if (!current.TypeArguments.IsEmpty) 33(args ??= new()).AddRange(current.TypeArguments);

System.Windows.Forms.Analyzers.CSharp (1)

System\Windows\Forms\CSharp\Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.cs (1)

58|| funcType.TypeArguments.Length != 1

System.Windows.Forms.Analyzers.VisualBasic (1)

Analyzers\AvoidPassingTaskWithoutCancellationToken\AvoidPassingTaskWithoutCancellationTokenAnalyzer.vb (1)

62If funcType.TypeArguments.Length <> 1 OrElse funcType.ContainingNamespace.ToString() <> "System" Then