NamedType

Options\SymbolNamesWithValueOptionTests.cs (3)

232Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType].ContainsKey("MyNamespace.MyClass")); 275Assert.Single(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]); 276Assert.Equal("SomeValue4", options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]["MyClass"]);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

DynamicallyAccessedMembersAnalyzer.cs (2)

154}, SymbolKind.NamedType); 164}, SymbolKind.NamedType);

ISymbolExtensions.cs (1)

167if (methodSymbol.ContainingSymbol?.Kind == SymbolKind.NamedType)

RequiresAnalyzerBase.cs (2)

75}, SymbolKind.NamedType); 82context.RegisterSymbolAction(AnalyzeImplicitBaseCtor, SymbolKind.NamedType);

TrimAnalysis\SingleValueExtensions.cs (1)

34SymbolKind.NamedType => new SystemTypeValue(new TypeProxy(type)),

MetricsOutputWriter.cs (2)

66case SymbolKind.NamedType: 139case SymbolKind.NamedType:

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

src\RoslynAnalyzers\Tools\Metrics\MetricsOutputWriter.cs (2)

66case SymbolKind.NamedType: 139case SymbolKind.NamedType:

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

MakeExeTypesInternalAnalyzer.cs (1)

137}, SymbolKind.NamedType);

ApiLifecycle\ApiLifecycleAnalyzer.cs (2)

53.Where(symbol => symbol.IsExternallyVisible() && symbol.Kind == SymbolKind.NamedType) 147.Where(symbol => symbol.IsExternallyVisible() && symbol.Kind == SymbolKind.NamedType)

BuildServiceProviderAnalyzer.cs (1)

21Debug.Assert(context.Symbol.Kind == SymbolKind.NamedType);

StartupAnalyzer.cs (1)

101}, SymbolKind.NamedType);

UseAuthorizationAnalyzer.cs (1)

22Debug.Assert(context.Symbol.Kind == SymbolKind.NamedType);

UseMvcAnalyzer.cs (1)

21Debug.Assert(context.Symbol.Kind == SymbolKind.NamedType);

Mvc\MvcAnalyzer.cs (1)

87}, SymbolKind.NamedType);

ComponentParameterAnalyzer.cs (1)

136}, SymbolKind.NamedType);

InternalUsageAnalyzer.cs (1)

52SymbolKind.NamedType,

ComponentParameterAnalyzer.cs (1)

123}, SymbolKind.NamedType);

InternalUsageAnalyzer.cs (1)

52SymbolKind.NamedType,

AttributesShouldNotBeAppliedToPageModelAnalyzer.cs (1)

64}, SymbolKind.NamedType);

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

1271case SymbolKind.NamedType:

DiagnosticAnalyzer\AnalyzerManager.AnalyzerExecutionContext.cs (1)

187case SymbolKind.NamedType:

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (2)

560case SymbolKind.NamedType: 593ImmutableArray.Create(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType));

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (6)

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray(); 171if (containingSymbol.Kind == SymbolKind.NamedType) 223not SymbolKind.NamedType); 824s.Kind == SymbolKind.NamedType && 833SymbolKind.NamedType);

DocumentationCommentId.cs (4)

779kind = SymbolKind.NamedType; 864case SymbolKind.NamedType: 1205if (symbol.Kind == SymbolKind.NamedType) 1232if (symbol.Kind == SymbolKind.Namespace || (symbol.Kind == SymbolKind.NamedType && ((INamedTypeSymbol)symbol).Arity == 0))

Emit\EditAndContinue\SymbolChanges.cs (2)

171if (synthesizedSymbol.Kind == SymbolKind.NamedType) 194if (synthesizedSymbol.Kind == SymbolKind.NamedType)

SymbolDisplay\AbstractSymbolDisplayVisitor_Minimal.cs (1)

70case SymbolKind.NamedType:

Symbols\SymbolKindExtensions.cs (1)

23case SymbolKind.NamedType:

FixAnalyzers\FixerWithFixAllAnalyzer.cs (1)

125context.RegisterSymbolStartAction(context => AnalyzeNamedType(context, analysisTypes), SymbolKind.NamedType);

ImplementationIsObsoleteAnalyzer.cs (1)

38context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.NamedType);

InternalImplementationOnlyAnalyzer.cs (1)

41context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.NamedType);

MetaAnalyzers\ClassIsNotDiagnosticAnalyzer.cs (1)

57}, SymbolKind.NamedType);

MetaAnalyzers\CompilerExtensionStrictApiAnalyzer.cs (1)

155SymbolKind.NamedType);

MetaAnalyzers\CompilerExtensionTargetFrameworkAnalyzer.cs (1)

107SymbolKind.NamedType);

MetaAnalyzers\DiagnosticAnalyzerAPIUsageAnalyzer.cs (1)

107}, SymbolKind.NamedType);

MetaAnalyzers\DiagnosticAnalyzerCorrectnessAnalyzer.cs (1)

36compilationContext.RegisterSymbolAction(c => analyzer.AnalyzeSymbol(c), SymbolKind.NamedType);

MetaAnalyzers\DiagnosticDescriptorCreationAnalyzer.cs (2)

321}, SymbolKind.NamedType); 447}, SymbolKind.NamedType);

MetaAnalyzers\DoNotUseFileTypesForAnalyzersOrGenerators.cs (1)

46context.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, diagnosticAnalyzer, codeFixProvider, isourceGenerator, iincrementalGenerator), SymbolKind.NamedType);

MetaAnalyzers\RegisterActionAnalyzer.cs (1)

183nameof(SymbolKind.NamedType),

MetaAnalyzers\SymbolIsBannedInAnalyzersAnalyzer.cs (1)

69context.RegisterSymbolAction(analyzePossibleAnalyzerOrGenerator, SymbolKind.NamedType);

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

63SymbolKind.NamedType,

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

2616if (capturedVariable.Kind == SymbolKind.NamedType)

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

SymbolIsBannedAnalyzerBase.cs (1)

63SymbolKind.NamedType,

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

81}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\NamingStyle\NamingStyleDiagnosticAnalyzerBase.cs (1)

34private static readonly ImmutableArray<SymbolKind> _symbolKinds = [SymbolKind.Event, SymbolKind.Method, SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Property];

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

781case SymbolKind.NamedType:

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

278}, SymbolKind.NamedType);

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

71}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

218}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)

113case SymbolKind.NamedType:

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

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray(); 171if (containingSymbol.Kind == SymbolKind.NamedType) 223not SymbolKind.NamedType); 824s.Kind == SymbolKind.NamedType && 833SymbolKind.NamedType);

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

134symbolInfo.CandidateSymbols.All(symbol => symbol.IsKind(SymbolKind.NamedType) &&

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

Binder\Binder.cs (3)

451case SymbolKind.NamedType: 606case SymbolKind.NamedType: 643RoslynDebug.Assert(symbol.Kind == SymbolKind.NamedType ||

Binder\Binder.IdentifierUsedAsValueFinder.cs (1)

290treatAsInstanceMemberAccess = !(symbol.IsStatic || symbol.Kind == SymbolKind.NamedType);

Binder\Binder_AnonymousTypes.cs (1)

199case SymbolKind.NamedType:

Binder\Binder_Constraints.cs (1)

35Debug.Assert((containingSymbol.Kind == SymbolKind.NamedType) || (containingSymbol.Kind == SymbolKind.Method));

Binder\Binder_Crefs.cs (1)

1017case SymbolKind.NamedType:

Binder\Binder_Expressions.cs (12)

Binder\Binder_Invocation.cs (1)

2141if (parameterType?.Kind == SymbolKind.NamedType &&

Binder\Binder_Lookup.cs (6)

377if (existingDefinition.Kind != SymbolKind.NamedType || arity == 0) 751if (symbol.Kind == SymbolKind.NamedType) 1365else if (nsOrType.Kind == SymbolKind.NamedType && originalBinder.IsEarlyAttributeBinder) 1389else if (nsOrType.Kind == SymbolKind.NamedType && originalBinder.IsEarlyAttributeBinder) 1784case SymbolKind.NamedType: 1839case SymbolKind.NamedType:

Binder\Binder_NameConflicts.cs (2)

160case SymbolKind.NamedType: 164return containingMemberOrLambda.ContainingSymbol?.Kind == SymbolKind.NamedType &&

Binder\Binder_Operators.cs (1)

1575if (type.Kind != SymbolKind.NamedType)

Binder\Binder_Patterns.cs (1)

888if ((InConstructorInitializer || InFieldInitializer) && ContainingMemberOrLambda.ContainingSymbol.Kind == SymbolKind.NamedType)

Binder\Binder_Symbols.cs (16)

Binder\InContainerBinder.cs (1)

54get { return (_container.Kind == SymbolKind.NamedType) && ((NamedTypeSymbol)_container).IsScriptClass; }

Binder\InMethodBinder.cs (2)

149if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType) 180if (refKind == RefKind.None && returnType.Kind == SymbolKind.NamedType)

Binder\Semantics\AccessCheck.cs (2)

73case SymbolKind.NamedType: 157case SymbolKind.NamedType:

Binder\Semantics\Conversions\ConversionsBase.cs (2)

1281if (destination.Kind == SymbolKind.NamedType) 1333if (destination.Kind == SymbolKind.NamedType)

Binder\Semantics\OverloadResolution\MethodTypeInference.cs (2)

725if (target.Type.Kind != SymbolKind.NamedType) 921if (formalType.Type.Kind != SymbolKind.NamedType)

Binder\Semantics\OverloadResolution\OverloadResolution.cs (1)

3376if (targetType.Kind != SymbolKind.NamedType)

Binder\WithUsingNamespacesAndTypesBinder.cs (2)

109case SymbolKind.NamedType: 229case SymbolKind.NamedType:

BoundTree\BoundExpressionExtensions.cs (1)

265return receiverType is NamedTypeSymbol { Kind: SymbolKind.NamedType, IsComImport: true };

Compilation\CSharpSemanticModel.cs (3)

1598if ((object)containingType != null && containingType.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)containingType).IsScriptClass) 1759if (lookupResult.Symbols.Any(t => t.Kind == SymbolKind.NamedType || t.Kind == SymbolKind.Namespace || t.Kind == SymbolKind.ErrorType)) 3997if (unwrappedSymbols.Count == 1 && unwrappedSymbols[0].Kind == SymbolKind.NamedType)

Compilation\SyntaxTreeSemanticModel.cs (4)

2475case SymbolKind.NamedType: 2511case SymbolKind.NamedType: 2539case SymbolKind.NamedType: 2596case SymbolKind.NamedType:

Compiler\ClsComplianceChecker.cs (8)

Compiler\DocumentationCommentCompiler.cs (3)

144symbol.Kind == SymbolKind.NamedType || 757case SymbolKind.NamedType: 781case SymbolKind.NamedType:

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (2)

568case SymbolKind.NamedType: 590case SymbolKind.NamedType: // Includes delegates.

Compiler\MethodCompiler.cs (1)

521case SymbolKind.NamedType:

Compiler\SynthesizedMetadataCompiler.cs (1)

96case SymbolKind.NamedType:

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (4)

374case SymbolKind.NamedType: 458SymbolKind.NamedType or SymbolKind.ErrorType => ((NamedTypeSymbol)otherContainer).TypeParameters, 779case SymbolKind.NamedType: 795if (symbol.Kind == SymbolKind.NamedType)

Emitter\Model\PEModuleBuilder.cs (7)

242case SymbolKind.NamedType: 251case SymbolKind.NamedType: 362case SymbolKind.NamedType: 373case SymbolKind.NamedType: 384case SymbolKind.NamedType: 577if (symbol.Kind == SymbolKind.NamedType) 1150case SymbolKind.NamedType:

Emitter\Model\TypeParameterSymbolAdapter.cs (2)

100if (AdaptedTypeParameterSymbol.ContainingSymbol.Kind == SymbolKind.NamedType) 115if (AdaptedTypeParameterSymbol.ContainingSymbol.Kind == SymbolKind.NamedType)

Emitter\NoPia\EmbeddedTypesManager.cs (1)

271if (member.Kind != SymbolKind.NamedType)

FlowAnalysis\NullableWalker.cs (1)

2232if (container.Kind == SymbolKind.NamedType)

SymbolDisplay\SymbolDisplayVisitor.cs (1)

108text = EscapeIdentifier(text, symbol?.Kind is SymbolKind.NamedType or SymbolKind.Alias);

Symbols\AbstractTypeMap.cs (1)

101case SymbolKind.NamedType:

Symbols\Attributes\AttributeData.cs (4)

340Debug.Assert(targetSymbol.Kind == SymbolKind.Assembly || targetSymbol.Kind == SymbolKind.NamedType || targetSymbol.Kind == SymbolKind.Method); 383Debug.Assert(targetSymbol.Kind == SymbolKind.Assembly || targetSymbol.Kind == SymbolKind.NamedType || targetSymbol.Kind == SymbolKind.Method); 437if (targetSymbol.Kind == SymbolKind.NamedType || targetSymbol.Kind == SymbolKind.Method) 744case SymbolKind.NamedType:

Symbols\Attributes\SourceAttributeData.cs (1)

290if (parameterType.Kind != SymbolKind.NamedType && parameterType.Kind != SymbolKind.ErrorType)

Symbols\Compilation_WellKnownMembers.cs (4)

223if (type.Kind != SymbolKind.NamedType || type.TypeKind != TypeKind.Class) 1111if (type.Kind != SymbolKind.NamedType) 1129if (type.Kind != SymbolKind.NamedType) 1220if (typeParam.ContainingSymbol.Kind != SymbolKind.NamedType)

Symbols\ConstraintsHelper.cs (1)

589if (type.Kind == SymbolKind.NamedType)

Symbols\ExtendedErrorTypeSymbol.cs (2)

37(containingSymbol.Kind == SymbolKind.NamedType) || 316case SymbolKind.NamedType:

Symbols\MemberSymbolExtensions.cs (5)

459case SymbolKind.NamedType: 510case SymbolKind.NamedType: 531case SymbolKind.NamedType: 563case SymbolKind.NamedType: 581case SymbolKind.NamedType:

Symbols\Metadata\PE\DynamicTypeDecoder.cs (1)

154case SymbolKind.NamedType:

Symbols\Metadata\PE\MetadataDecoder.cs (3)

231goto case SymbolKind.NamedType; 232case SymbolKind.NamedType: 544Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType);

Symbols\Metadata\PE\PENamedTypeSymbol.cs (2)

1524Debug.Assert(SymbolKind.Event.ToSortOrder() < SymbolKind.NamedType.ToSortOrder()); 1692if (member.Kind == SymbolKind.NamedType)

Symbols\Metadata\PE\TupleTypeDecoder.cs (1)

173case SymbolKind.NamedType:

Symbols\MethodSymbolExtensions.cs (1)

108case SymbolKind.NamedType:

Symbols\NamedTypeSymbol.cs (1)

809return SymbolKind.NamedType;

Symbols\OverriddenOrHiddenMembersHelpers.cs (4)

591case SymbolKind.NamedType: 641case SymbolKind.NamedType: 716bool needToSearchForRelated = representativeMember.Kind != SymbolKind.Field && representativeMember.Kind != SymbolKind.NamedType && 855Debug.Assert(representativeMember.Kind != SymbolKind.NamedType);

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)

85if (s.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)s).IsExplicitDefinitionOfNoPiaLocalType)

Symbols\Retargeting\RetargetingSymbolTranslator.cs (3)

164Debug.Assert(symbol.Kind != SymbolKind.NamedType || ((NamedTypeSymbol)symbol).PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive); 322if (type.ContainingSymbol.Kind != SymbolKind.NamedType && 660case SymbolKind.NamedType:

Symbols\Source\LocalFunctionSymbol.cs (1)

453Debug.Assert(tpEnclosing.ContainingSymbol.Kind == SymbolKind.NamedType);

Symbols\Source\SourceAssemblySymbol.cs (2)

2082case SymbolKind.NamedType: 2238if (forwardedType.Kind != SymbolKind.NamedType)

Symbols\Source\SourceMemberContainerSymbol.cs (3)

468case SymbolKind.NamedType: 2065if (symbol.Kind == SymbolKind.NamedType || 4666case SymbolKind.NamedType:

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

663case SymbolKind.NamedType: 672Debug.Assert(symbol.Kind == SymbolKind.Field || symbol.Kind == SymbolKind.NamedType);

Symbols\Source\SourceModuleSymbol.cs (2)

180case SymbolKind.NamedType: 628case SymbolKind.NamedType:

Symbols\Source\SourceNamedTypeSymbol.cs (1)

94if (containingSymbol.Kind == SymbolKind.NamedType)

Symbols\Source\SourceNamespaceSymbol.AliasesAndUsings.cs (1)

789else if (imported.Kind == SymbolKind.NamedType)

Symbols\SubstitutedNamedTypeSymbol.cs (2)

250if (t.Kind == SymbolKind.NamedType) 300if (t.Kind == SymbolKind.NamedType)

Symbols\Symbol.cs (3)

649case SymbolKind.NamedType: 903Debug.Assert(this.Kind == SymbolKind.NamedType || this.Kind == SymbolKind.Method); 1647case SymbolKind.NamedType:

Symbols\Symbol_Attributes.cs (2)

66case SymbolKind.NamedType: 935case SymbolKind.NamedType:

Symbols\SymbolDistinguisher.cs (1)

58case SymbolKind.NamedType:

Symbols\SymbolExtensions.cs (6)

137case SymbolKind.NamedType: 183case SymbolKind.NamedType: 203case SymbolKind.NamedType: 260case SymbolKind.NamedType: 303var upperLevelType = symbol.Kind == SymbolKind.NamedType ? (NamedTypeSymbol)symbol : symbol.ContainingType; 336case SymbolKind.NamedType:

Symbols\SymbolKindExtensions.cs (1)

22case SymbolKind.NamedType:

Symbols\Synthesized\SynthesizedContainer.cs (1)

60if (ContainingSymbol.Kind == SymbolKind.NamedType && ContainingSymbol.IsImplicitlyDeclared)

Symbols\Synthesized\SynthesizedSubstitutedTypeParameterSymbol.cs (1)

45if (ContainingSymbol.Kind == SymbolKind.NamedType &&

Symbols\Tuples\TupleTypeSymbol.cs (2)

690case SymbolKind.NamedType: 1064case SymbolKind.NamedType:

Symbols\TypeSymbol.cs (1)

2404if (this.IsAbstract && member.IsAbstract && member.Kind != SymbolKind.NamedType)

Symbols\TypeSymbolExtensions.cs (4)

330return type.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)type).IsInterface; 1748case SymbolKind.NamedType: 1920case SymbolKind.NamedType: 2277if (type.Kind == SymbolKind.NamedType)

Symbols\TypeUnification.cs (2)

140case SymbolKind.NamedType: 273case SymbolKind.NamedType:

Symbols\VarianceSafety.cs (2)

61case SymbolKind.NamedType: 337case SymbolKind.NamedType:

Utilities\TypeSymbolExtensions.cs (2)

46case SymbolKind.NamedType: 129case SymbolKind.NamedType:

src\Analyzers\CSharp\Analyzers\MakeStructFieldsWritable\CSharpMakeStructFieldsWritableDiagnosticAnalyzer.cs (1)

69}, SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (1)

51}, SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\MakeStructReadOnly\CSharpMakeStructReadOnlyDiagnosticAnalyzer.cs (1)

67}, SymbolKind.NamedType);

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

80context.RegisterSymbolStartAction(context => Analyzer.AnalyzeNamedTypeStart(this, context, namedTypeToAnalyzer), SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\UseSystemThreadingLock\CSharpUseSystemThreadingLockDiagnosticAnalyzer.cs (1)

69context.RegisterSymbolStartAction(AnalyzeNamedType, SymbolKind.NamedType);

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true)

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateDeconstructMethodCodeFixProvider.cs (1)

80if (type?.Kind != SymbolKind.NamedType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

216if (symbol?.Kind == SymbolKind.NamedType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (2)

1014if (conditionOrType.GetBestOrAllSymbols().FirstOrDefault() is { Kind: SymbolKind.NamedType }) 3061case SymbolKind.NamedType:

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

703case SymbolKind.NamedType:

CommandLineTests.cs (2)

16006SymbolKind.NamedType); 16023SymbolKind.NamedType);

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (4)

42SymbolKind.NamedType 98Assert.True(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 111Assert.True(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 856=> context.RegisterSymbolAction(OnSymbol, SymbolKind.NamedType);

SymbolKey\SymbolKeyTestBase.cs (2)

162kinds.Add(SymbolKind.NamedType); 226case SymbolKind.NamedType:

CodeGen\CodeGenClosureLambdaTests.cs (2)

3979}, c.GetMembers().Where(member => member.Kind == SymbolKind.NamedType).Select(member => member.ToString())); 4048}, c.GetMembers().Where(member => member.Kind == SymbolKind.NamedType).Select(member => member.ToString()));

CodeGen\CodeGenDeconstructTests.cs (19)

CodeGen\CodeGenRefLocalTests.cs (1)

4087Assert.Equal(SymbolKind.NamedType, alias.Target.Kind);

CodeGen\CodeGenTupleTest.cs (17)

Attributes\AttributeTests_MarshalAs.cs (2)

34foreach (NamedTypeSymbol type in compilation.GlobalNamespace.GetMembers().Where(s => s.Kind == SymbolKind.NamedType)) 68foreach (NamedTypeSymbol type in compilation.GlobalNamespace.GetMembers().Where(s => s.Kind == SymbolKind.NamedType))

Attributes\AttributeTests_Security.cs (12)

Attributes\AttributeTests_Tuples.cs (1)

285case SymbolKind.NamedType:

Diagnostics\DiagnosticAnalyzerTests.cs (14)

Diagnostics\GetDiagnosticsTests.cs (2)

840var analyzers = ImmutableArray.Create<DiagnosticAnalyzer>(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.NamedType, OperationKind.VariableDeclaration)); 1854}, SymbolKind.NamedType);

FlowAnalysis\FlowTestBase.cs (1)

75case SymbolKind.NamedType:

Semantics\ExtensionTests.cs (5)

104Assert.Equal(SymbolKind.NamedType, symbol.Kind); 34603Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 35804Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 51458context.RegisterSymbolAction(handle, SymbolKind.NamedType); 51558context.RegisterSymbolStartAction(handleStart, SymbolKind.NamedType);

Semantics\PatternMatchingTests.cs (3)

3449Assert.Equal(SymbolKind.NamedType, typeInfo1.Type.Kind); 3453Assert.Equal(SymbolKind.NamedType, typeInfo1.Type.Kind); 3459Assert.Equal(SymbolKind.NamedType, typeInfo2.Type.Kind);

Semantics\PrimaryConstructorTests.cs (4)

4083context.RegisterSymbolAction(Handle, SymbolKind.NamedType); 4169context.RegisterSymbolStartAction(Handle1, SymbolKind.NamedType); 5486context.RegisterSymbolAction(Handle, SymbolKind.NamedType); 5573context.RegisterSymbolStartAction(Handle1, SymbolKind.NamedType);

Semantics\RecordTests.cs (2)

26625context.RegisterSymbolAction(Handle, SymbolKind.NamedType); 26720context.RegisterSymbolStartAction(Handle1, SymbolKind.NamedType);

ChangeSignature\CSharpChangeSignatureService.cs (1)

166if (typeSymbol != null && typeSymbol.IsKind(SymbolKind.NamedType) && ((ITypeSymbol)typeSymbol).TypeKind == TypeKind.Delegate)

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

140member.Kind == SymbolKind.NamedType ||

Completion\CompletionProviders\SymbolCompletionProvider.cs (1)

257else if (symbol.IsKind(SymbolKind.NamedType) || symbol is IAliasSymbol aliasSymbol && aliasSymbol.Target.IsType)

NavigationBar\CSharpNavigationBarItemService.cs (1)

77member.Kind == SymbolKind.NamedType ||

src\Analyzers\CSharp\Analyzers\MakeStructFieldsWritable\CSharpMakeStructFieldsWritableDiagnosticAnalyzer.cs (1)

69}, SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (1)

51}, SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\MakeStructReadOnly\CSharpMakeStructReadOnlyDiagnosticAnalyzer.cs (1)

67}, SymbolKind.NamedType);

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

80context.RegisterSymbolStartAction(context => Analyzer.AnalyzeNamedTypeStart(this, context, namedTypeToAnalyzer), SymbolKind.NamedType);

src\Analyzers\CSharp\Analyzers\UseSystemThreadingLock\CSharpUseSystemThreadingLockDiagnosticAnalyzer.cs (1)

69context.RegisterSymbolStartAction(AnalyzeNamedType, SymbolKind.NamedType);

src\Analyzers\CSharp\CodeFixes\GenerateMethod\GenerateDeconstructMethodCodeFixProvider.cs (1)

80if (type?.Kind != SymbolKind.NamedType)

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

1518}, SymbolKind.NamedType);

Semantics\ColorColorTests.cs (19)

Semantics\InteractiveSemanticModelTests.cs (4)

164Assert.Equal(SymbolKind.NamedType, semanticInfo.Symbol.Kind); 215Assert.Equal(SymbolKind.NamedType, semanticInfo.Symbol.Kind); 247Assert.Equal(SymbolKind.NamedType, sortedCandidates[0].Kind); 249Assert.Equal(SymbolKind.NamedType, sortedCandidates[1].Kind);

Semantics\LocalFunctionTests.cs (3)

7893VerifyTParameter(comp, 1, "C", symbolKind: SymbolKind.NamedType, lookupFinds: "System.String C.TParameter"); 8367VerifyTParameter(comp, 1, "C", symbolKind: SymbolKind.NamedType, lookupFinds: "System.String C.TParameter"); 8429VerifyTParameter(comp, 1, "C", lookupFinds: "System.String C.TParameter", symbolKind: SymbolKind.NamedType);

Semantics\LookupTests.cs (1)

1533var typeA = (INamedTypeSymbol)actual_lookupSymbols.Where((sym) => sym.Name.Equals("A") && sym.Kind == SymbolKind.NamedType).Single();

Semantics\NativeIntegerTests.cs (2)

228Assert.Equal(SymbolKind.NamedType, type.Kind); 243Assert.Equal(SymbolKind.NamedType, type.Kind);

Semantics\RecordStructTests.cs (2)

6258context.RegisterSymbolAction(Handle, SymbolKind.NamedType); 6354context.RegisterSymbolStartAction(Handle1, SymbolKind.NamedType);

Semantics\ScriptSemanticsTests.cs (1)

597if (symbol.Kind == SymbolKind.NamedType)

Semantics\TopLevelStatementsTests.cs (6)

709Assert.Equal(SymbolKind.NamedType, local.ContainingSymbol.ContainingSymbol.Kind); 4270Assert.Equal(SymbolKind.NamedType, local.ContainingSymbol.ContainingSymbol.Kind); 4948Assert.Equal(SymbolKind.NamedType, label.ContainingSymbol.ContainingSymbol.Kind); 5033Assert.Equal(SymbolKind.NamedType, label.ContainingSymbol.ContainingSymbol.Kind); 6705context.RegisterSymbolStartAction(Handle2, SymbolKind.NamedType); 7370context.RegisterSymbolAction(Handle3, SymbolKind.NamedType);

SourceGeneration\GeneratorDriverTests.cs (1)

185context.RegisterSymbolAction(Handle, SymbolKind.NamedType);

Compilation\GetSemanticInfoTests.cs (1)

1562Assert.Equal(SymbolKind.NamedType, symbol.Kind);

Compilation\GetUnusedImportDirectivesTests.cs (1)

197Assert.Equal(SymbolKind.NamedType, info.Symbol.Kind);

Compilation\SemanticModelAPITests.cs (16)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (8)

1090Assert.Equal(SymbolKind.NamedType, symbols[0].Kind); 1131Assert.Equal(SymbolKind.NamedType, symbols[0].Kind); 1180Assert.Equal(SymbolKind.NamedType, symbols[0].Kind); 1388Assert.True(symbolsInC.Any(s => s.Name == "A" && s.Kind == SymbolKind.NamedType)); 1389Assert.True(symbolsInC.Any(s => s.Name == "B" && s.Kind == SymbolKind.NamedType)); 1390Assert.True(symbolsInC.Any(s => s.Name == "C" && s.Kind == SymbolKind.NamedType)); 3639Assert.Equal(SymbolKind.NamedType, enumTypeSymbol.Kind); 4747Assert.Equal(SymbolKind.NamedType, enumSymbol.Kind);

Compilation\SemanticModelGetSemanticInfoTests.cs (77)

DeclarationTests.cs (1)

265Assert.Equal(SymbolKind.NamedType, comp.GlobalNamespace.GetMembers()[0].Kind);

DocumentationComments\CrefTests.cs (2)

742Assert.Equal(SymbolKind.NamedType, GetReferencedSymbol(crefSyntax, compilation).Kind); 787Assert.Equal(SymbolKind.NamedType, GetReferencedSymbol(crefSyntax, compilation).Kind);

DocumentationComments\DocumentationCommentIDTests.cs (1)

212Assert.Equal(SymbolKind.NamedType, symbol.Kind);

Symbols\Metadata\MetadataTypeTests.cs (4)

88Assert.Equal(SymbolKind.NamedType, class1.Kind); 138Assert.Equal(SymbolKind.NamedType, type1.Kind); 186Assert.Equal(SymbolKind.NamedType, type1.Kind); 236Assert.Equal(SymbolKind.NamedType, type1.Kind);

Symbols\Metadata\PE\LoadingFields.cs (1)

109Assert.Equal(SymbolKind.NamedType, csFields.GetMembers("FFF").Single().Kind);

Symbols\Metadata\PE\LoadingMethods.cs (2)

95Assert.Equal(SymbolKind.NamedType, varC108.Kind); 100Assert.Equal(SymbolKind.NamedType, sameName1.Kind);

Symbols\Metadata\PE\MissingTypeReferences.cs (1)

210Assert.Equal(SymbolKind.NamedType, genericBase.ContainingSymbol.Kind);

Symbols\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.cs (9)

95Assert.Equal(SymbolKind.NamedType, importedField.Type.Kind); 98Assert.Equal(SymbolKind.NamedType, outer.Kind); 118Assert.Equal(SymbolKind.NamedType, var1.Type.Kind); 165Assert.Equal(SymbolKind.NamedType, var1.Type.Kind); 354Assert.Equal(SymbolKind.NamedType, var1.Type.Kind); 371Assert.Equal(SymbolKind.NamedType, var1.Type.Kind); 412Assert.Equal(SymbolKind.NamedType, localField.Type.Kind); 450Assert.Equal(SymbolKind.NamedType, m.ReturnType.Kind); 468Assert.Equal(SymbolKind.NamedType, classLocalType.Kind);

Symbols\Metadata\PE\NoPiaLocalHideAndTypeSubstitutionTests.cs (3)

102Assert.Equal(SymbolKind.NamedType, methodSymbol.Parameters.Single(arg => arg.Name == "arg").Type.Kind); 441Assert.Equal(SymbolKind.NamedType, methodSymbol.ReturnType.Kind); 482Assert.Equal(SymbolKind.NamedType, embeddedType.ReturnType.Kind);

Symbols\Retargeting\RetargetingTests.cs (2)

1176case SymbolKind.NamedType: 1300case SymbolKind.NamedType:

Symbols\Source\DelegateTests.cs (2)

129Assert.Equal(SymbolKind.NamedType, v.Kind); 207Assert.Equal(SymbolKind.NamedType, d.Kind);

Symbols\Source\MethodTests.cs (3)

42Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 124Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 148Assert.Equal(SymbolKind.NamedType, x.Type.Kind);

Symbols\Source\SourcePlusMetadataTests.cs (8)

29Assert.Equal(SymbolKind.NamedType, x.BaseType().Kind); 31Assert.Equal(SymbolKind.NamedType, y.BaseType().Kind); 46Assert.Equal(SymbolKind.NamedType, x.BaseType().Kind); 64Assert.Equal(SymbolKind.NamedType, y.BaseType().Kind); 66Assert.Equal(SymbolKind.NamedType, z.BaseType().Kind); 84Assert.Equal(SymbolKind.NamedType, a.BaseType().Kind); 255Assert.Equal(SymbolKind.NamedType, key.Kind); 256Assert.Equal(SymbolKind.NamedType, nam.Kind);

Symbols\TypeTests.cs (4)

855Assert.Equal(SymbolKind.NamedType, igoo.Kind); 868Assert.Equal(SymbolKind.NamedType, classA.Kind); 880Assert.Equal(SymbolKind.NamedType, structS.Kind); 909Assert.Equal(SymbolKind.NamedType, varA.Type.Kind);

EmitMetadataTestBase.cs (1)

146kind = SymbolKind.NamedType;

Extensions.cs (2)

444if (typeSym.Kind == SymbolKind.NamedType && 848case SymbolKind.NamedType:

Metadata\WinMdDumpTest.cs (1)

58case SymbolKind.NamedType:

Recommendations\CSharpRecommendationServiceRunner.cs (3)

684if (leftHandBinding.GetBestOrAllSymbols().FirstOrDefault().MatchesKind(SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Alias)) 781symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace or SymbolKind.Alias) 803if (symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace or SymbolKind.TypeParameter)

Simplification\CSharpSimplificationService.Expander.cs (1)

646if (symbol.Kind is SymbolKind.Namespace or SymbolKind.NamedType)

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (1)

141(symbol.Kind != SymbolKind.Namespace && symbol.Kind != SymbolKind.NamedType))

Simplification\Simplifiers\ExpressionSimplifier.cs (1)

420if (rightSymbol != null && (rightSymbol.IsStatic || rightSymbol.Kind == SymbolKind.NamedType))

Simplification\Simplifiers\NameSimplifier.cs (1)

272if (!name.IsVar && symbol.Kind == SymbolKind.NamedType && !name.IsLeftSideOfQualifiedName())

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

216if (symbol?.Kind == SymbolKind.NamedType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (2)

1014if (conditionOrType.GetBestOrAllSymbols().FirstOrDefault() is { Kind: SymbolKind.NamedType }) 3061case SymbolKind.NamedType:

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

703case SymbolKind.NamedType:

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (1)

154if (RenameSymbol.Kind == SymbolKind.NamedType &&

Peek\PeekHelpers.cs (1)

64case SymbolKind.NamedType:

CodeFixes\CodeFixServiceTests.cs (1)

1182}, SymbolKind.NamedType);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

1040}, SymbolKind.NamedType);

Symbols\INamedTypeSymbolExtensions.cs (2)

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

Symbols\ISymbolExtensions.cs (1)

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

Symbols\ISymbolExtensions_Accessibility.cs (1)

123case SymbolKind.NamedType:

Symbols\ITypeSymbolExtensions.cs (1)

598case SymbolKind.NamedType:

Symbols\SymbolEquivalenceComparer.cs (1)

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (1)

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

ChangeSignature\AbstractChangeSignatureService.cs (1)

276if (symbol.Definition.Kind == SymbolKind.NamedType)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

365case SymbolKind.NamedType:

CodeLens\CodeLensFindReferenceProgress.cs (1)

121var isConstructorInvocation = _queriedSymbol.Kind == SymbolKind.NamedType &&

Completion\CommonCompletionUtilities.cs (1)

106case SymbolKind.NamedType:

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

282case SymbolKind.NamedType:

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (2)

314SymbolKind.NamedType => GetDisplayName((INamedTypeSymbol)symbol), 2655case SymbolKind.NamedType when oldMember is INamedTypeSymbol { DelegateInvokeMethod: { } oldInvokeMethod }:

ExternalAccess\UnitTesting\SolutionCrawler\UnitTestingWorkCoordinator.UnitTestingSemanticChangeProcessor.cs (1)

199=> symbol.Kind == SymbolKind.NamedType;

GenerateType\AbstractGenerateTypeService.State.cs (1)

297!symbol.IsKind(SymbolKind.NamedType) ||

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (2)

36SymbolKind.NamedType or 49SymbolKind.NamedType => new WrappedNamedTypeSymbol((INamedTypeSymbol)m, canImplementImplicitly, docCommentFormattingService),

MetadataAsSource\MetadataAsSourceFileService.cs (1)

302case SymbolKind.NamedType:

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

58topLevelNamedType.Kind != SymbolKind.NamedType)

QuickInfo\CommonSemanticQuickInfoProvider.cs (2)

175s1.Kind == SymbolKind.NamedType ? -1 : 176s2.Kind == SymbolKind.NamedType ? 1 : 0)];

Rename\SymbolicRenameInfo.cs (1)

171if (symbol.Kind == SymbolKind.NamedType &&

Shared\Extensions\ISymbolExtensions_2.cs (1)

55case SymbolKind.NamedType:

Shared\Extensions\ISymbolExtensions_Sorting.cs (3)

163if (s1.Kind == SymbolKind.NamedType || s2.Kind == SymbolKind.NamedType) 167: s1.Kind == SymbolKind.NamedType ? -1 : 1;

src\Analyzers\Core\Analyzers\MakeFieldReadonly\AbstractMakeFieldReadonlyDiagnosticAnalyzer.cs (1)

81}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\NamingStyle\NamingStyleDiagnosticAnalyzerBase.cs (1)

34private static readonly ImmutableArray<SymbolKind> _symbolKinds = [SymbolKind.Event, SymbolKind.Method, SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Property];

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

781case SymbolKind.NamedType:

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

278}, SymbolKind.NamedType);

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

71}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\UseAutoProperty\AbstractUseAutoPropertyAnalyzer.cs (1)

218}, SymbolKind.NamedType);

src\Analyzers\Core\Analyzers\UseCompoundAssignment\UseCompoundAssignmentUtilities.cs (1)

113case SymbolKind.NamedType:

src\Analyzers\Core\CodeFixes\AliasAmbiguousType\AbstractAliasAmbiguousTypeCodeFixProvider.cs (1)

134symbolInfo.CandidateSymbols.All(symbol => symbol.IsKind(SymbolKind.NamedType) &&

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

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray(); 171if (containingSymbol.Kind == SymbolKind.NamedType) 223not SymbolKind.NamedType); 824s.Kind == SymbolKind.NamedType && 833SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

DeclarePublicApiAnalyzer.cs (1)

144SymbolKind.NamedType,

DeclarePublicApiAnalyzer.Impl.cs (1)

587if (symbol.Kind == SymbolKind.NamedType)

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

Compilation\CompilationExtensions.cs (1)

264case SymbolKind.NamedType:

Diagnostics\CommonDiagnosticAnalyzers.cs (21)

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (3)

75SymbolKind.NamedType, 102SymbolKind.NamedType); 286SymbolKind.NamedType);

Diagnostics\TrackingDiagnosticAnalyzer.cs (2)

84SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Parameter, SymbolKind.Property 133new { SymbolKind = SymbolKind.NamedType, MethodKind = InvalidMethodKind, ReturnsVoid = false },

Diagnostics\AnalysisContextInfoTests.cs (1)

79c.RegisterSymbolAction(b => ThrowIfMatch(nameof(c.RegisterSymbolAction), new AnalysisContextInfo(b.Compilation, b.Symbol)), SymbolKind.NamedType);

Binding\Binder.vb (1)

403Case SymbolKind.NamedType

Binding\Binder_Attributes.vb (2)

184ElseIf symbol.Kind <> SymbolKind.NamedType Then 246If errorType.CandidateSymbols.Length = 1 AndAlso errorType.CandidateSymbols(0).Kind = SymbolKind.NamedType Then

Binding\Binder_Constraints.vb (2)

18Debug.Assert((containingSymbol.Kind = SymbolKind.NamedType) OrElse (containingSymbol.Kind = SymbolKind.Method)) 48Debug.Assert((containingSymbol.Kind = SymbolKind.NamedType) OrElse (containingSymbol.Kind = SymbolKind.Method))

Binding\Binder_Conversions.vb (1)

699If targetType.Kind <> SymbolKind.NamedType Then

Binding\Binder_Expressions.vb (3)

1919Case SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Parameter 3298Case SymbolKind.NamedType, SymbolKind.ErrorType 3358Case SymbolKind.NamedType, SymbolKind.ErrorType

Binding\Binder_Imports.vb (1)

191If importedSymbol.Kind = SymbolKind.NamedType Then

Binding\Binder_Invocation.vb (1)

288ElseIf targetType.Kind = SymbolKind.NamedType AndAlso targetType.TypeKind = TypeKind.Delegate Then

Binding\Binder_Lookup.vb (2)

167If unwrappedSym.Kind = SymbolKind.NamedType AndAlso unwrappedSym.EmbeddedSymbolKind = EmbeddedSymbolKind.EmbeddedAttribute AndAlso 181Case SymbolKind.NamedType, SymbolKind.ErrorType

Binding\Binder_ObjectInitializer.vb (1)

28extendedErrorType.CandidateSymbols(0).Kind = SymbolKind.NamedType Then

Binding\Binder_Statements.vb (2)

4091collectionType.Kind <> SymbolKind.NamedType AndAlso 4696If structureType.Kind = SymbolKind.NamedType Then

Binding\Binder_Symbols.vb (5)

304If diagBag.AccumulatesDiagnostics AndAlso typeSymbol.Kind = SymbolKind.NamedType AndAlso binder.SourceModule.AnyReferencedAssembliesAreLinked Then 717While currentSymbol IsNot Nothing AndAlso currentSymbol.Kind = SymbolKind.NamedType 976Dim isLeftUnboundGenericType As Boolean = leftSymbol.Kind = SymbolKind.NamedType AndAlso DirectCast(leftSymbol, NamedTypeSymbol).IsUnboundGenericType 992If lookupResult.HasSingleSymbol AndAlso lookupResult.SingleSymbol.Kind = SymbolKind.NamedType Then 1053Dim isLeftUnboundGenericType As Boolean = leftSymbol.Kind = SymbolKind.NamedType AndAlso DirectCast(leftSymbol, NamedTypeSymbol).IsUnboundGenericType

Binding\DocumentationCommentCrefBinder.vb (4)

693If containingSymbol.Kind <> SymbolKind.NamedType Then 706If containingSymbol.Kind = SymbolKind.NamedType Then 768Case SymbolKind.NamedType, SymbolKind.ArrayType 855Case SymbolKind.NamedType, SymbolKind.ErrorType

Binding\DocumentationCommentCrefBinder_Compat.vb (2)

185Case SymbolKind.NamedType, SymbolKind.ArrayType 400Case SymbolKind.NamedType, SymbolKind.ErrorType

Binding\DocumentationCommentParamBinder.vb (1)

28Case SymbolKind.NamedType

Binding\DocumentationCommentTypeParamBinder.vb (1)

41Case SymbolKind.NamedType

Binding\ForOrForEachBlockBinder.vb (1)

88result.Symbols(0).Kind <> SymbolKind.NamedType AndAlso

Binding\ImportedTypesAndNamespacesMembersBinder.vb (2)

136If importedSym.NamespaceOrType.Kind = SymbolKind.NamedType Then 150If importedSym.NamespaceOrType.Kind = SymbolKind.NamedType Then

Binding\LookupResult.vb (1)

993Debug.Assert(type.Kind = SymbolKind.NamedType)

Compilation\ClsComplianceChecker.vb (7)

290Debug.Assert(symbol.Kind = SymbolKind.NamedType OrElse symbol.Kind = SymbolKind.Field OrElse symbol.Kind = SymbolKind.Property OrElse symbol.Kind = SymbolKind.Event OrElse symbol.Kind = SymbolKind.Method) 305If symbol.Kind = SymbolKind.NamedType Then 327ElseIf symbol.IsMustOverride AndAlso symbol.Kind <> SymbolKind.NamedType Then 657Debug.Assert(symbol.Kind = SymbolKind.NamedType OrElse Not (TypeOf symbol Is TypeSymbol), "Type kinds without declarations are handled elsewhere.") 696Case SymbolKind.Assembly, SymbolKind.NetModule, SymbolKind.NamedType 731If symbol.IsFromCompilation(Me._compilation) OrElse symbol.Kind <> SymbolKind.NamedType Then 845Return symbol.Kind = SymbolKind.NamedType AndAlso (DirectCast(symbol, NamedTypeSymbol)).IsImplicitClass

Compilation\DocumentationComments\DocumentationCommentCompiler.Common.vb (2)

735Case SymbolKind.NamedType 766Case SymbolKind.NamedType

Compilation\DocumentationComments\DocumentationCommentCompiler.Includes.vb (1)

119Case SymbolKind.NamedType

Compilation\DocumentationComments\DocumentationCommentCompiler.vb (1)

120symbol.Kind = SymbolKind.NamedType OrElse

Compilation\MethodCompiler.vb (2)

394If symbol.Kind = SymbolKind.NamedType Then 660Case SymbolKind.NamedType

Compilation\SemanticModel.vb (2)

1080If candidateSymbols.Length = 1 AndAlso candidateSymbols(0).Kind = SymbolKind.NamedType Then 3535Case SymbolKind.NamedType

Compilation\SyntaxTreeSemanticModel.vb (2)

528SymbolKind.NamedType 1077Case SymbolKind.NamedType

Compilation\SynthesizedMetadataCompiler.vb (1)

52Case SymbolKind.NamedType

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.vb (1)

110If containingSymbol.Kind = SymbolKind.NamedType Then

Emit\EditAndContinue\VisualBasicSymbolMatcher.vb (4)

320Case SymbolKind.NamedType 348Case SymbolKind.NamedType, 509Case SymbolKind.NamedType, 524If symbol.Kind = SymbolKind.NamedType Then

Emit\NoPia\EmbeddedTypesManager.vb (1)

223If member.Kind <> SymbolKind.NamedType Then

Emit\PEModuleBuilder.vb (7)

217Case SymbolKind.Namespace, SymbolKind.NamedType 225Case SymbolKind.NamedType 233Case SymbolKind.NamedType 360If sym.Kind = SymbolKind.NamedType Then 500If symbol.Kind = SymbolKind.NamedType Then 664Case SymbolKind.Namespace, SymbolKind.NamedType 672Case SymbolKind.NamedType

Emit\SymbolTranslator.vb (1)

255Case SymbolKind.NamedType, SymbolKind.ErrorType

Emit\TypeParameterSymbolAdapter.vb (4)

92If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 104If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 147If kind = SymbolKind.NamedType Then 157If kind = SymbolKind.NamedType Then

Lowering\AsyncRewriter\AsyncRewriter.vb (1)

382If returnType.Kind = SymbolKind.NamedType AndAlso

Semantics\AccessCheck.vb (7)

106Case SymbolKind.NamedType 498Case SymbolKind.NamedType, SymbolKind.ErrorType 603Case SymbolKind.NamedType 867If Not (exposingMember.Kind = SymbolKind.NamedType AndAlso IsTypeNestedIn(exposedType, DirectCast(exposingMember, NamedTypeSymbol))) Then 871Debug.Assert(exposingMember.Kind = SymbolKind.NamedType) 998If member.Kind = SymbolKind.NamedType Then 1171If member.Kind = SymbolKind.NamedType Then

Semantics\Operators.vb (4)

438ElseIf (sourceType.Kind = SymbolKind.NamedType OrElse sourceType.Kind = SymbolKind.TypeParameter) AndAlso 439(targetType.Kind = SymbolKind.NamedType OrElse targetType.Kind = SymbolKind.TypeParameter) Then 2866If type1 IsNot Nothing AndAlso type1.Kind = SymbolKind.NamedType AndAlso Not type1.IsInterfaceType() Then 2885If type2 IsNot Nothing AndAlso type2.Kind = SymbolKind.NamedType AndAlso Not type2.IsInterfaceType() Then

Semantics\OverloadResolution.vb (4)

4944If leftType.Kind = SymbolKind.NamedType AndAlso rightType.Kind = SymbolKind.NamedType Then 5080If symbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 5115Case SymbolKind.NamedType, SymbolKind.ErrorType

Semantics\TypeInference\TypeArgumentInference.vb (8)

Symbols\Attributes\AttributeData.vb (4)

214Debug.Assert(targetSymbol.Kind = SymbolKind.Assembly OrElse targetSymbol.Kind = SymbolKind.NamedType OrElse targetSymbol.Kind = SymbolKind.Method) 284Debug.Assert(targetSymbol.Kind = SymbolKind.Assembly OrElse targetSymbol.Kind = SymbolKind.NamedType OrElse targetSymbol.Kind = SymbolKind.Method) 333If targetSymbol.Kind = SymbolKind.NamedType OrElse targetSymbol.Kind = SymbolKind.Method Then 594Case SymbolKind.NamedType

Symbols\Attributes\SourceAttributeData.vb (1)

172If parameterType.Kind <> SymbolKind.NamedType AndAlso parameterType.Kind <> SymbolKind.ErrorType Then

Symbols\BaseTypeAnalysis.vb (1)

55Debug.Assert(current.Head.Kind = SymbolKind.NamedType)

Symbols\ConstraintsHelper.vb (1)

438If type.Kind = SymbolKind.NamedType Then

Symbols\EmbeddedSymbols\EmbeddedSymbolManager.SymbolsCollection.vb (3)

265Case SymbolKind.NamedType 307Debug.Assert(symbol.Kind = SymbolKind.NamedType OrElse 345Case SymbolKind.NamedType

Symbols\Metadata\PE\MetadataDecoder.vb (1)

202Case SymbolKind.NamedType, SymbolKind.ErrorType

Symbols\Metadata\PE\PENamedTypeSymbol.vb (1)

645Case SymbolKind.NamedType

Symbols\Metadata\PE\TupleTypeDecoder.vb (1)

137Case SymbolKind.NamedType

Symbols\NamedTypeSymbol.vb (1)

663Return SymbolKind.NamedType

Symbols\Retargeting\RetargetingNamespaceSymbol.vb (1)

75If s.Kind = SymbolKind.NamedType AndAlso DirectCast(s, NamedTypeSymbol).IsExplicitDefinitionOfNoPiaLocalType Then

Symbols\Retargeting\RetargetingSymbolTranslator.vb (3)

126Debug.Assert(symbol.Kind <> SymbolKind.NamedType OrElse DirectCast(symbol, NamedTypeSymbol).PrimitiveTypeCode = PrimitiveTypeCode.NotPrimitive) 245If type.ContainingSymbol.Kind <> SymbolKind.NamedType AndAlso 551Case SymbolKind.ErrorType, SymbolKind.NamedType

Symbols\Source\OverrideHidingHelper.vb (2)

363If member.Kind = SymbolKind.NamedType AndAlso 364hiddenMember.Kind = SymbolKind.NamedType AndAlso

Symbols\Source\SourceMemberContainerTypeSymbol.vb (2)

299If member.Kind <> SymbolKind.NamedType Then 821Case SymbolKind.NamedType

Symbols\Source\SourceMethodSymbol.vb (1)

1133Return container.FindMember(delegateIdentifier.ValueText, SymbolKind.NamedType, delegateIdentifier.Span, tree)

Symbols\Source\SourceModuleSymbol.vb (2)

316Case SymbolKind.NamedType 1177Case SymbolKind.NamedType

Symbols\Source\SourceNamedTypeSymbol.vb (2)

95If containingSymbol.Kind = SymbolKind.NamedType Then 511Case SymbolKind.NamedType

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (1)

380Case SymbolKind.Field, SymbolKind.NamedType

Symbols\Source\SourceNamedTypeSymbol_GroupClass.vb (3)

213If current.Kind = SymbolKind.NamedType Then 228Case SymbolKind.Namespace, SymbolKind.NamedType 242Case SymbolKind.NamedType

Symbols\SubstitutedNamedType.vb (2)

368Case SymbolKind.NamedType 451Case SymbolKind.NamedType

Symbols\Symbol.vb (2)

210Case SymbolKind.NamedType 611Case SymbolKind.NamedType

Symbols\Symbol_Attributes.vb (2)

95Case SymbolKind.NamedType 590Case SymbolKind.Assembly, SymbolKind.NamedType, SymbolKind.Method

Symbols\SymbolExtensions.vb (3)

33Case SymbolKind.NamedType 308Case SymbolKind.NamedType, SymbolKind.ErrorType 404Dim upperLevelType = If(symbol.Kind = SymbolKind.NamedType, DirectCast(symbol, NamedTypeSymbol), symbol.ContainingType)

Symbols\Tuples\TupleTypeSymbol.vb (5)

145Return SymbolKind.NamedType 788Case SymbolKind.NamedType 955Debug.Assert(Not GetMembers().Any(Function(m) m.Kind = SymbolKind.NamedType)) 961Debug.Assert(Not GetMembers().Any(Function(m) m.Kind = SymbolKind.NamedType)) 967Debug.Assert(Not GetMembers().Any(Function(m) m.Kind = SymbolKind.NamedType))

Symbols\TypeSubstitution.vb (1)

569((targetGenericDefinition.Kind = SymbolKind.NamedType OrElse targetGenericDefinition.Kind = SymbolKind.ErrorType) AndAlso

Symbols\TypeSymbolExtensions.vb (4)

134Return type.Kind = SymbolKind.NamedType AndAlso DirectCast(type, NamedTypeSymbol).IsInterface 191type.Kind = SymbolKind.NamedType AndAlso 212type.Kind = SymbolKind.NamedType AndAlso 497If this.Kind = SymbolKind.NamedType AndAlso Not DirectCast(this, NamedTypeSymbol).IsInterface Then

Symbols\UnboundGenericType.vb (1)

508If member.Kind = SymbolKind.NamedType Then

Symbols\WellKnownMembers.vb (4)

355If type.Kind <> SymbolKind.NamedType Then 580If type.Kind <> SymbolKind.NamedType Then 599If type.Kind <> SymbolKind.NamedType Then 670If typeParam.ContainingSymbol.Kind <> SymbolKind.NamedType Then

Utilities\TypeUnification.vb (2)

106Case SymbolKind.NamedType, SymbolKind.ErrorType 243Case SymbolKind.NamedType, SymbolKind.ErrorType

Editing\SyntaxGenerator.cs (2)

764case SymbolKind.NamedType: 893case SymbolKind.NamedType:

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

35SymbolKind.NamedType => true,

Recommendations\AbstractRecommendationService.cs (1)

73case SymbolKind.NamedType:

Rename\ConflictEngine\ConflictResolver.cs (2)

233if (renamedSymbol.ContainingSymbol.IsKind(SymbolKind.NamedType)) 269if (renamedSymbol.IsKind(SymbolKind.NamedType) && renamedSymbol.ContainingSymbol is INamespaceOrTypeSymbol)

Rename\RenameUtilities.cs (1)

197if (containingType.Kind == SymbolKind.NamedType)

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (2)

107referencedSymbol.ContainingSymbol.Kind == SymbolKind.NamedType && 199if (referencedSymbol.Kind == SymbolKind.NamedType && referencedSymbol.Locations.All(l => l.IsInSource))

Shared\Extensions\INamespaceSymbolExtensions.cs (1)

187if (namespaceOrType.Kind == SymbolKind.NamedType)

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

FindReferencesTests.cs (4)

138var typeSymbol = result.Where(@ref => @ref.Definition.Kind == SymbolKind.NamedType).Single(); 577var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType); 612var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType); 656var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType);

Parsing\Parser.LogProperties.cs (1)

337symType.Kind == SymbolKind.NamedType &&

Parsing\Parser.Records.cs (1)

146extractedType.Kind == SymbolKind.NamedType &&

LogParserUtilitiesTests.cs (1)

154paramTypeMock.SetupGet(x => x.Kind).Returns(SymbolKind.NamedType);

Analyzers\AddGeneratedComClassAnalyzer.cs (1)

61}, SymbolKind.NamedType);

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

146}, SymbolKind.NamedType);

Analyzers\GeneratedComInterfaceAttributeAnalyzer.cs (1)

46}, SymbolKind.NamedType);

BaseTestClassAnalyzer.cs (1)

46context.RegisterSymbolAction(analyzerImpl.AnalyzeNamedType, SymbolKind.NamedType);

BestFriendOnPublicDeclarationsAnalyzer.cs (1)

53context.RegisterSymbolAction(c => AnalyzeCore(c, attribute), SymbolKind.NamedType, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property);

Library\ClassView\AbstractSyncClassViewCommandHandler.cs (1)

92SymbolKind.NamedType or

Library\ObjectBrowser\AbstractListItemFactory.cs (1)

139if (symbol.Kind == SymbolKind.NamedType)

Venus\ContainedLanguageCodeSupport.cs (2)

103if (eventType.Kind != SymbolKind.NamedType) 177if (eventType.Kind != SymbolKind.NamedType || ((INamedTypeSymbol)eventType).DelegateInvokeMethod == null)

CodeModel\CSharpCodeModelService.cs (2)

2995case SymbolKind.NamedType: 3821if (typeSymbol.Kind != SymbolKind.NamedType ||

CodeModel\CSharpCodeModelService_Prototype.cs (1)

37case SymbolKind.NamedType:

GlyphExtensionsTests.cs (13)

CodeModel\AbstractCodeModelObject_CodeGen.cs (2)

72accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination), 252accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination),

CodeModel\AbstractCodeModelService.cs (1)

218case SymbolKind.NamedType:

CodeModel\MetadataNameHelpers.cs (1)

106case SymbolKind.NamedType:

Features\InlineRename\XamlEditorInlineRenameService.cs (1)

128case SymbolKind.NamedType:

AbstractDoNotCopyValue.cs (2)

160SymbolKind.NamedType, 1512case SymbolKind.NamedType:

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (1)

52context.RegisterSymbolAction(context => AnalyzeNamedType(context, nonDefaultableAttribute, knownNonDefaultableTypes), SymbolKind.NamedType);

DoNotMixAttributesFromDifferentVersionsOfMEF.cs (1)

57compilationContext.RegisterSymbolAction(c => AnalyzeSymbol(c, exportAttributes, attributeUsageAttribute), SymbolKind.NamedType);

ExportedPartsShouldHaveImportingConstructor.cs (1)

78}, SymbolKind.NamedType);

ImportingConstructorShouldBeObsolete.cs (1)

71}, SymbolKind.NamedType);

PartsExportedWithMEFv2MustBeMarkedAsShared.cs (1)

75}, SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType:

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (2)

61compilationContext.RegisterSymbolAction(compilationAnalyzer.AnalyzeNamedType, SymbolKind.NamedType); 138type.Kind == SymbolKind.NamedType &&

TestExportsShouldNotBeDiscoverable.cs (1)

68}, SymbolKind.NamedType);

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Editing\CSharpImportAdder.cs (1)

216if (symbol?.Kind == SymbolKind.NamedType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (2)

1014if (conditionOrType.GetBestOrAllSymbols().FirstOrDefault() is { Kind: SymbolKind.NamedType }) 3061case SymbolKind.NamedType:

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

703case SymbolKind.NamedType:

GenerateFilteredReferenceAssembliesTask.cs (1)

354SymbolKind.NamedType => SymbolKindFlags.NamedType,

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

EnumsShouldHavePluralNames.cs (1)

66compilationContext.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, flagsAttribute), SymbolKind.NamedType);

IdentifiersShouldBeSpelledCorrectly.cs (3)

255SymbolKind.NamedType, 491SymbolKind.NamedType => symbol.CreateDiagnostic(TypeRule, misspelledWord, symbol.ToDisplayString()), 511SymbolKind.NamedType => symbol.CreateDiagnostic(TypeMoreMeaningfulNameRule, symbolName),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.AssemblyMetricData.cs (1)

62Debug.Assert(child.Children.All(grandChild => grandChild.Symbol.Kind == SymbolKind.NamedType));

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (5)

38SymbolKind.NamedType or 43Debug.Assert(depthOfInheritance.HasValue == (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace || symbol.Kind == SymbolKind.NamedType)); 138case SymbolKind.NamedType: 271SymbolKind.NamedType => await NamedTypeMetricData.ComputeAsync((INamedTypeSymbol)symbol, context).ConfigureAwait(false), 309SymbolKind.NamedType => NamedTypeMetricData.ComputeSynchronously((INamedTypeSymbol)symbol, context),

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType);

src\RoslynAnalyzers\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

166'T' => SymbolKind.NamedType, 274case SymbolKind.NamedType:

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

164case SymbolKind.NamedType:

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

203m.Kind != SymbolKind.NamedType && 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType &&

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

354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity,

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

123case SymbolKind.NamedType:

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

598case SymbolKind.NamedType:

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

198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

126SymbolKind.NamedType => NamedTypesAreEquivalent((INamedTypeSymbol)x, (INamedTypeSymbol)y, equivalentTypesWithDifferingAssemblies),

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

70SymbolKind.NamedType => CombineHashCodes((INamedTypeSymbol)x, currentHash),

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

42public override SymbolKind Kind => SymbolKind.NamedType;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\LanguageServices\SemanticsFactsService\AbstractSemanticFactsService.cs (1)

36s is { Kind: SymbolKind.NamedType, IsStatic: true };

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\SymbolFinder\SymbolFinderInternal.cs (1)

30case SymbolKind.NamedType: