SymbolKind

9374 references to SymbolKind

Analyzer.Utilities.UnitTests (9)

Lightup\LightupHelpersTests.cs (1)

100SymbolKind ISymbol.Kind => throw new NotImplementedException();

Options\SymbolNamesWithValueOptionTests.cs (8)

231Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Namespace].ContainsKey("MyNamespace")); 232Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType].ContainsKey("MyNamespace.MyClass")); 233Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Field].ContainsKey("MyNamespace.MyClass.MyField")); 234Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Property].ContainsKey("MyNamespace.MyClass.MyProperty")); 235Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Event].ContainsKey("MyNamespace.MyClass.MyEvent")); 236Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Method].ContainsKey("MyNamespace.MyClass.MyMethod(")); 275Assert.Single(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]); 276Assert.Equal("SomeValue4", options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]["MyClass"]);

ConfigurationSchemaGenerator (4)

RuntimeSource\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

GenerateDocumentationAndConfigFiles (259)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

33case SymbolKind.Assembly: 34case SymbolKind.Namespace when ((INamespaceSymbol)symbol).IsGlobalNamespace: 37case SymbolKind.Parameter: 114public static ImmutableHashSet<SymbolKind> GetAnalyzedSymbolKindsOption( 119ImmutableHashSet<SymbolKind> defaultSymbolKinds) 124private static ImmutableHashSet<SymbolKind> GetAnalyzedSymbolKindsOption( 129ImmutableHashSet<SymbolKind> defaultSymbolKinds)

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

174/// Option to configure analyzed symbol kinds, i.e. <see cref="Microsoft.CodeAnalysis.SymbolKind"/>. 175/// Allowed option values: One or more fields of <see cref="Microsoft.CodeAnalysis.SymbolKind"/> as a comma separated list.

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

26internal const SymbolKind AllKinds = SymbolKind.ErrorType; 54private readonly ImmutableDictionary<SymbolKind, ImmutableDictionary<string, TValue>> _wildcardNamesBySymbolKind; 64ImmutableDictionary<SymbolKind, ImmutableDictionary<string, TValue>> wildcardNamesBySymbolKind) 77_wildcardNamesBySymbolKind = ImmutableDictionary<SymbolKind, ImmutableDictionary<string, TValue>>.Empty; 92var wildcardNamesBuilder = PooledDictionary<SymbolKind, PooledDictionary<string, TValue>>.GetInstance(); 142static void ProcessWildcardName(NameParts parts, PooledDictionary<SymbolKind, PooledDictionary<string, TValue>> wildcardNamesBuilder) 161'E' => (SymbolKind?)SymbolKind.Event, 162'F' => SymbolKind.Field, 163'M' => SymbolKind.Method, 164'N' => SymbolKind.Namespace, 165'P' => SymbolKind.Property, 166'T' => SymbolKind.NamedType, 271case SymbolKind.Event: 272case SymbolKind.Field: 273case SymbolKind.Method: 274case SymbolKind.NamedType: 275case SymbolKind.Namespace: 276case SymbolKind.Property: 279case SymbolKind.Assembly: 280case SymbolKind.ErrorType: 281case SymbolKind.NetModule: 377internal ref readonly ImmutableDictionary<SymbolKind, ImmutableDictionary<string, TValue>> WildcardNamesBySymbolKind => ref _symbolNamesWithValueOption._wildcardNamesBySymbolKind;

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

154case SymbolKind.Namespace: 164case SymbolKind.NamedType: 171case SymbolKind.Method: 172case SymbolKind.Property: 173case SymbolKind.Field: 174case SymbolKind.Event: 175case SymbolKind.Parameter: 176case SymbolKind.Local:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

103private static readonly SymbolKindOrTypeKind s_namespace = new(SymbolKind.Namespace); 108private static readonly SymbolKindOrTypeKind s_property = new(SymbolKind.Property); 111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 112private static readonly SymbolKindOrTypeKind s_event = new(SymbolKind.Event); 114private static readonly SymbolKindOrTypeKind s_parameter = new(SymbolKind.Parameter); 115private static readonly SymbolKindOrTypeKind s_typeParameter = new(SymbolKind.TypeParameter); 116private static readonly SymbolKindOrTypeKind s_local = new(SymbolKind.Local); 362case SymbolKind.Namespace: 365case SymbolKind.Property: 368case SymbolKind.Field: 371case SymbolKind.Event: 374case SymbolKind.Parameter: 377case SymbolKind.TypeParameter: 380case SymbolKind.Local:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

42public bool TryGetQualifyMemberAccessOption(SymbolKind symbolKind, [NotNullWhen(true)] out CodeStyleOption2<bool>? option) 46SymbolKind.Field => QualifyFieldAccess, 47SymbolKind.Property => QualifyPropertyAccess, 48SymbolKind.Method => QualifyMethodAccess, 49SymbolKind.Event => QualifyEventAccess,

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

54var kind = symbol.Kind; 135var kind = (SymbolKind)reader.ReadInteger(); 255SemanticModel semanticModel, SyntaxNode containerDeclaration, SymbolKind kind, string localName, CancellationToken cancellationToken)

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

758&& symbol.IsKind(SymbolKind.Method) 1037if (receiverType.IsKind(SymbolKind.TypeParameter) && !receiverType.IsReferenceType) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1058receiverSymbol.IsKind(SymbolKind.Property); 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

203m.Kind != SymbolKind.NamedType && 214if (member.Kind != SymbolKind.Property) 304return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType && 314if (member.Kind != SymbolKind.Property) 487case SymbolKind.Field: 498case SymbolKind.Property:

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

40case SymbolKind.Alias: 45case SymbolKind.Parameter: 49case SymbolKind.TypeParameter: 54while (symbol != null && symbol.Kind != SymbolKind.Namespace) 121if (symbol.Kind is SymbolKind.Event or SymbolKind.Property) 152if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 189if (symbol.Kind == SymbolKind.Event) 194if (symbol.Kind == SymbolKind.Property) 235=> symbol is { Kind: SymbolKind.ArrayType }; 243public static bool IsKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind) 246public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind) 249public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind1, SymbolKind kind2) 255public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind1, SymbolKind kind2, SymbolKind kind3) 261public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, params SymbolKind[] kinds) 271=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum }; 354SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity, 355SymbolKind.Method => ((IMethodSymbol)symbol).Arity, 592if (symbol.Kind != SymbolKind.Local) 778public static bool IsKind<TSymbol>(this ISymbol symbol, SymbolKind kind, [NotNullWhen(true)] out TSymbol? result) where TSymbol : class, ISymbol

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

97case SymbolKind.Alias: 100case SymbolKind.ArrayType: 103case SymbolKind.PointerType: 106case SymbolKind.FunctionPointerType: 123case SymbolKind.NamedType: 126case SymbolKind.ErrorType: 127case SymbolKind.Discard: 130case SymbolKind.TypeParameter: 131case SymbolKind.Parameter: 132case SymbolKind.Local: 133case SymbolKind.Label: 134case SymbolKind.Namespace: 135case SymbolKind.DynamicType: 136case SymbolKind.Assembly: 137case SymbolKind.NetModule: 138case SymbolKind.RangeVariable: 139case SymbolKind.Preprocessing: 143case SymbolKind.Method: 144case SymbolKind.Property: 145case SymbolKind.Field: 146case SymbolKind.Event: 158if (symbol.ContainingSymbol.IsKind(SymbolKind.DynamicType)) 195if (typeArg.Kind != SymbolKind.TypeParameter &&

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 44SymbolKind.Property => HaveSameSignature((IPropertySymbol)symbol1, (IPropertySymbol)symbol2, caseSensitive), 45SymbolKind.Event => HaveSameSignature((IEventSymbol)symbol1, (IEventSymbol)symbol2, caseSensitive), 161case SymbolKind.Method: 166case SymbolKind.Property: 173case SymbolKind.Event:

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

177=> symbol.IsKind(SymbolKind.Alias, out IAliasSymbol? alias) ? alias.Target : symbol; 179private static SymbolKind GetKindAndUnwrapAlias(ref ISymbol symbol) 181var k = symbol.Kind; 182if (k == SymbolKind.Alias) 198=> symbol.IsKind(SymbolKind.NamedType, out ITypeSymbol? typeSymbol) && typeSymbol.SpecialType == SpecialType.System_Object;

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

26case SymbolKind.Event: 27case SymbolKind.Field: 28case SymbolKind.Method: 29case SymbolKind.Local: 30case SymbolKind.NamedType: 31case SymbolKind.Parameter: 32case SymbolKind.Property: 33case SymbolKind.TypeParameter: 34case SymbolKind.Namespace:

ILLink.RoslynAnalyzer (23)

CompilationExtensions.cs (4)

91case SymbolKind.Alias: 96case SymbolKind.Parameter: 100case SymbolKind.TypeParameter: 105while (symbol != null && symbol.Kind != SymbolKind.Namespace)

DataFlow\DynamicallyAccessedMembersBinder.cs (4)

461case SymbolKind.Field: 462case SymbolKind.Method: 463case SymbolKind.Property: 464case SymbolKind.Event:

DynamicallyAccessedMembersAnalyzer.cs (5)

154}, SymbolKind.NamedType); 160}, SymbolKind.Method); 164}, SymbolKind.NamedType); 168}, SymbolKind.Property); 172}, SymbolKind.Field);

ISymbolExtensions.cs (1)

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

RequiresAnalyzerBase.cs (5)

38private protected virtual ImmutableArray<(Action<SymbolAnalysisContext> Action, SymbolKind[] SymbolKind)> ExtraSymbolActions { get; } = ImmutableArray<(Action<SymbolAnalysisContext> Action, SymbolKind[] SymbolKind)>.Empty; 69}, SymbolKind.Method); 75}, SymbolKind.NamedType); 82context.RegisterSymbolAction(AnalyzeImplicitBaseCtor, SymbolKind.NamedType);

TrimAnalysis\SingleValueExtensions.cs (4)

33SymbolKind.TypeParameter => new GenericParameterValue((ITypeParameterSymbol)type), 34SymbolKind.NamedType => new SystemTypeValue(new TypeProxy(type)), 36SymbolKind.ArrayType => new SystemTypeValue(new TypeProxy(type.BaseType!)), 37SymbolKind.ErrorType => UnknownValue.Instance,

Metrics (268)

MetricsOutputWriter.cs (10)

66case SymbolKind.NamedType: 80case SymbolKind.Method: 81case SymbolKind.Field: 82case SymbolKind.Event: 83case SymbolKind.Property: 129case SymbolKind.Assembly: 134case SymbolKind.Namespace: 139case SymbolKind.NamedType: 144case SymbolKind.Property: 145case SymbolKind.Event:

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

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

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType); 59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null); 81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

72if (symbol.Kind == SymbolKind.Namespace) 248if (declaredSymbol != null && !Equals(symbol, declaredSymbol) && declaredSymbol.Kind != SymbolKind.Parameter) 414SymbolKind.Method => ((IMethodSymbol)member).Parameters, 415SymbolKind.Property => ((IPropertySymbol)member).Parameters,

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Metrics.Legacy (270)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

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

52var members = namedType.GetMembers().Where(m => m.Kind != SymbolKind.NamedType); 56members = members.Where(m => m.Kind is not SymbolKind.Field and not SymbolKind.Property and not SymbolKind.Event); 81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Microsoft.Analyzers.Extra (4)

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

635foreach (var methodSymbol in targetClassSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Method).OfType<IMethodSymbol>())

MakeExeTypesInternalAnalyzer.cs (1)

137}, SymbolKind.NamedType);

UsingToStringInLoggersAnalyzer.cs (1)

28if (operationBlockContext.OwningSymbol.Kind != SymbolKind.Method)

Utilities\SymbolExtensions.cs (1)

39while (symbol.Kind != SymbolKind.Namespace)

Microsoft.Analyzers.Local (4)

ApiLifecycle\ApiLifecycleAnalyzer.cs (2)

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

ApiLifecycle\AssemblyAnalysis.cs (1)

202if (member.Kind != SymbolKind.Method)

Utilities\SymbolExtensions.cs (1)

15while (symbol.Kind != SymbolKind.Namespace)

Microsoft.AspNetCore.Analyzers (5)

BuildServiceProviderAnalyzer.cs (1)

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

StartupAnalyzer.cs (2)

60if (context.OwningSymbol.Kind != SymbolKind.Method) 101}, SymbolKind.NamedType);

UseAuthorizationAnalyzer.cs (1)

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

UseMvcAnalyzer.cs (1)

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

Microsoft.AspNetCore.App.Analyzers (1)

Mvc\MvcAnalyzer.cs (1)

87}, SymbolKind.NamedType);

Microsoft.AspNetCore.Components.Analyzers (6)

ComponentParameterAnalyzer.cs (1)

136}, SymbolKind.NamedType);

InternalUsageAnalyzer.cs (5)

52SymbolKind.NamedType, 53SymbolKind.Field, 54SymbolKind.Method, 55SymbolKind.Property, 56SymbolKind.Event);

Microsoft.AspNetCore.Components.SdkAnalyzers (6)

ComponentParameterAnalyzer.cs (1)

123}, SymbolKind.NamedType);

InternalUsageAnalyzer.cs (5)

52SymbolKind.NamedType, 53SymbolKind.Field, 54SymbolKind.Method, 55SymbolKind.Property, 56SymbolKind.Event);

Microsoft.AspNetCore.Mvc.Analyzers (4)

AttributesShouldNotBeAppliedToPageModelAnalyzer.cs (2)

53}, SymbolKind.Method); 64}, SymbolKind.NamedType);

TopLevelParameterNameAnalyzer.cs (2)

81}, SymbolKind.Method); 112member.Kind != SymbolKind.Property)

Microsoft.AspNetCore.Mvc.Api.Analyzers (1)

SymbolApiResponseMetadataProvider.cs (1)

111.FirstOrDefault(m => m.Kind == SymbolKind.Method && m.IsStatic && m.DeclaredAccessibility == Accessibility.Public);

Microsoft.AspNetCore.OpenApi.SourceGenerators (8)

Helpers\ISymbolExtensions.cs (5)

16if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 146if (symbol.Kind is SymbolKind.Event or SymbolKind.Property)

XmlComments\XmlComment.InheritDoc.cs (3)

78case SymbolKind.Method: 79case SymbolKind.Property: 80case SymbolKind.Event:

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

HubClientProxyGenerator.Parser.cs (2)

285.Where(member => member.Kind == SymbolKind.Method) 289.Where(member => member.Kind == SymbolKind.Method)

HubServerProxyGenerator.Parser.cs (2)

262.Where(member => member.Kind == SymbolKind.Method) 266.Where(member => member.Kind == SymbolKind.Method)

Microsoft.CodeAnalysis (135)

CodeGen\MetadataNamedArgument.cs (1)

41bool Cci.IMetadataNamedArgument.IsField => _entity.Kind == SymbolKind.Field;

CodeGen\PermissionSetAttribute.cs (1)

86member => member.Kind == SymbolKind.Property && ((IPropertySymbol)member).Type.SpecialType == SpecialType.System_String));

Compilation\Compilation.cs (10)

1711case SymbolKind.Assembly: 1713case SymbolKind.PointerType: 1716case SymbolKind.ArrayType: 1719case SymbolKind.Alias: 1722case SymbolKind.Discard: 1725case SymbolKind.FunctionPointerType: 1741case SymbolKind.DynamicType: 1742case SymbolKind.ErrorType: 1743case SymbolKind.Preprocessing: 1744case SymbolKind.Namespace:

Compilation\SymbolInfo.cs (2)

70Debug.Assert(symbol is null || symbol.Kind != SymbolKind.Namespace || ((INamespaceSymbol)symbol).NamespaceKind != NamespaceKindNamespaceGroup); 73Debug.Assert(item.Kind != SymbolKind.Namespace || ((INamespaceSymbol)item).NamespaceKind != NamespaceKindNamespaceGroup);

DiagnosticAnalyzer\AnalysisScope.cs (1)

222!((symbol.Kind == SymbolKind.Namespace && ((INamespaceSymbol)symbol).IsGlobalNamespace));

DiagnosticAnalyzer\AnalyzerDriver.cs (3)

2575var getSymbol = topmostNodeForAnalysis != declaringReferenceSyntax || declaredSymbol.Kind == SymbolKind.Namespace; 2942declaredSymbol.Kind == SymbolKind.Namespace && 2943otherSymbol.Kind == SymbolKind.Namespace &&

DiagnosticAnalyzer\AnalyzerDriver.GroupedAnalyzerActions.cs (1)

18/// <see cref="AnalyzerActions"/> grouped by <see cref="DiagnosticAnalyzer"/>, and possibly other entities, such as <see cref="OperationKind"/>, <see cref="SymbolKind"/>, etc.

DiagnosticAnalyzer\AnalyzerExecutor.cs (6)

1268case SymbolKind.Method: 1269case SymbolKind.Event: 1270case SymbolKind.Property: 1271case SymbolKind.NamedType: 1272case SymbolKind.Namespace: // We are exposing assembly/module attributes on global namespace symbol. 1275case SymbolKind.Field:

DiagnosticAnalyzer\AnalyzerManager.AnalyzerExecutionContext.cs (2)

187case SymbolKind.NamedType: 191case SymbolKind.Namespace:

DiagnosticAnalyzer\CompilationWithAnalyzers.cs (1)

906symbolDeclaredEvent.Symbol.Kind != SymbolKind.Namespace)

DiagnosticAnalyzer\DiagnosticAnalysisContext.cs (12)

75/// <param name="symbolKinds">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches one of the <see cref="SymbolKind"/> values.</param> 76public void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds) 86/// <param name="symbolKinds">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches one of the <see cref="SymbolKind"/> values.</param> 87public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds); 93/// <param name="symbolKind">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches the given <see cref="SymbolKind"/>.</param> 94public virtual void RegisterSymbolStartAction(Action<SymbolStartAnalysisContext> action, SymbolKind symbolKind) 370/// <param name="symbolKinds">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches one of the <see cref="SymbolKind"/> values.</param> 371public void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds) 381/// <param name="symbolKinds">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches one of the <see cref="SymbolKind"/> values.</param> 382public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds); 388/// <param name="symbolKind">Action will be executed only if an <see cref="ISymbol"/>'s Kind matches the given <see cref="SymbolKind"/>.</param> 389public virtual void RegisterSymbolStartAction(Action<SymbolStartAnalysisContext> action, SymbolKind symbolKind)

DiagnosticAnalyzer\DiagnosticAnalysisContextHelpers.cs (2)

24internal static void VerifyArguments<TContext>(Action<TContext> action, ImmutableArray<SymbolKind> symbolKinds) 117private static void VerifySymbolKinds(ImmutableArray<SymbolKind> symbolKinds)

DiagnosticAnalyzer\DiagnosticAnalyzerAction.cs (4)

24public ImmutableArray<SymbolKind> Kinds { get; } 26public SymbolAnalyzerAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> kinds, DiagnosticAnalyzer analyzer) 37public SymbolKind Kind { get; } 39public SymbolStartAnalyzerAction(Action<SymbolStartAnalysisContext> action, SymbolKind kind, DiagnosticAnalyzer analyzer)

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (13)

60public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds) 66public override void RegisterSymbolStartAction(Action<SymbolStartAnalysisContext> action, SymbolKind symbolKind) 165public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds) 171public override void RegisterSymbolStartAction(Action<SymbolStartAnalysisContext> action, SymbolKind symbolKind) 535public void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds) 545if (symbolKinds.Contains(SymbolKind.Parameter)) 554case SymbolKind.Method: 557case SymbolKind.Property: 560case SymbolKind.NamedType: 593ImmutableArray.Create(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType)); 597public void RegisterSymbolStartAction(Action<SymbolStartAnalysisContext> action, SymbolKind symbolKind)

DiagnosticAnalyzer\SuppressMessageAttributeState.cs (2)

80if (symbol.Kind != SymbolKind.Namespace) 175if (symbol.Kind == SymbolKind.Namespace)

DiagnosticAnalyzer\SuppressMessageAttributeState.TargetSymbolResolver.cs (10)

119candidateMembers.Where(s => s.Kind == SymbolKind.NamedType).ToImmutableArray() : 120candidateMembers.Where(s => s.Kind != SymbolKind.NamedType).ToImmutableArray(); 171if (containingSymbol.Kind == SymbolKind.NamedType) 203singleResult = candidateMembers.FirstOrDefault(s => s.Kind == SymbolKind.Namespace); 217singleResult = candidateMembers.FirstOrDefault(s => s.Kind == SymbolKind.Event); 222s.Kind is not SymbolKind.Namespace and 223not SymbolKind.NamedType); 824s.Kind == SymbolKind.NamedType && 832s.Kind is SymbolKind.Namespace or 833SymbolKind.NamedType);

DocumentationCommentId.cs (20)

759SymbolKind kind; 764kind = SymbolKind.Event; 767kind = SymbolKind.Field; 770kind = SymbolKind.Method; 773kind = SymbolKind.Namespace; 776kind = SymbolKind.Property; 779kind = SymbolKind.NamedType; 830else if (kind == SymbolKind.Namespace) 861case SymbolKind.Method: 864case SymbolKind.NamedType: 867case SymbolKind.Property: 870case SymbolKind.Event: 873case SymbolKind.Field: 876case SymbolKind.Namespace: 1205if (symbol.Kind == SymbolKind.NamedType) 1232if (symbol.Kind == SymbolKind.Namespace || (symbol.Kind == SymbolKind.NamedType && ((INamedTypeSymbol)symbol).Arity == 0)) 1274if (symbol.Kind == SymbolKind.Namespace) 1414if (symbol.Kind == SymbolKind.Field) 1430if (symbol.Kind == SymbolKind.Event)

Emit\EditAndContinue\DefinitionMap.cs (1)

711if (member is { Kind: SymbolKind.Field, IsStatic: false })

Emit\EditAndContinue\SymbolChanges.cs (9)

171if (synthesizedSymbol.Kind == SymbolKind.NamedType) 176if (synthesizedSymbol.Kind == SymbolKind.Method) 194if (synthesizedSymbol.Kind == SymbolKind.NamedType) 202if (synthesizedSymbol.Kind == SymbolKind.Method) 268if (symbol.Kind == SymbolKind.Namespace) 418if (newMember.Kind == SymbolKind.Method) 441else if (newMember.Kind == SymbolKind.Property) 518case SymbolKind.NetModule: 519case SymbolKind.Assembly:

Operations\ControlFlowGraphBuilder.cs (2)

4027return resource.Type == null || resource.Type.Kind == SymbolKind.DynamicType; 7957.Where(m => m.Kind == SymbolKind.Property)

SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

SymbolDisplay\AbstractSymbolDisplayVisitor.cs (2)

199if (containingSymbol.Kind == SymbolKind.Namespace && 319if (member.Kind == SymbolKind.Field)

SymbolDisplay\AbstractSymbolDisplayVisitor_Minimal.cs (2)

70case SymbolKind.NamedType: 73case SymbolKind.Method:

Symbols\Attributes\CommonAttributeData.cs (1)

79if (attributeType.ContainingSymbol?.Kind != SymbolKind.Namespace)

Symbols\ISymbol.cs (2)

26/// Gets the <see cref="SymbolKind"/> indicating what kind of symbol it is. 28SymbolKind Kind { get; }

Symbols\ISymbolExtensions.cs (1)

97if (sym.Kind == SymbolKind.Namespace)

Symbols\ISymbolInternal.cs (2)

20/// Gets the <see cref="SymbolKind"/> indicating what kind of symbol it is. 22SymbolKind Kind { get; }

Symbols\ITypeSymbol.cs (1)

263return type?.Kind == SymbolKind.DynamicType;

Symbols\SymbolKind.cs (2)

127internal const SymbolKind FunctionType = (SymbolKind)255;

Symbols\SymbolKindExtensions.cs (18)

11public static int ToSortOrder(this SymbolKind kind) 15case SymbolKind.Field: 17case SymbolKind.Method: 19case SymbolKind.Property: 21case SymbolKind.Event: 23case SymbolKind.NamedType: 25case SymbolKind.Namespace: 27case SymbolKind.Alias: 29case SymbolKind.ArrayType: 31case SymbolKind.Assembly: 37case SymbolKind.Label: 39case SymbolKind.Local: 41case SymbolKind.NetModule: 43case SymbolKind.Parameter: 45case SymbolKind.RangeVariable: 47case SymbolKind.TypeParameter: 49case SymbolKind.DynamicType: 51case SymbolKind.Preprocessing:

Microsoft.CodeAnalysis.Analyzers (327)

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

55if (context.OwningSymbol?.Kind != SymbolKind.Method)

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

55if (context.OwningSymbol?.Kind != SymbolKind.Method)

MetaAnalyzers\RegisterActionAnalyzer.cs (9)

180nameof(SymbolKind.Event), 181nameof(SymbolKind.Field), 182nameof(SymbolKind.Method), 183nameof(SymbolKind.NamedType), 184nameof(SymbolKind.Namespace), 185nameof(SymbolKind.Parameter), 186nameof(SymbolKind.Property)); 314if (symbol == null || symbol.Kind != SymbolKind.Method || !symbol.Name.StartsWith("Register", StringComparison.Ordinal)) 365symbol.Kind == SymbolKind.Field &&

MetaAnalyzers\ReportDiagnosticAnalyzer.cs (2)

185if (symbol != null && symbol.Kind == SymbolKind.Field) 202symbol.Kind != SymbolKind.Method ||

MetaAnalyzers\SymbolIsBannedInAnalyzersAnalyzer.cs (1)

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

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

63SymbolKind.NamedType, 64SymbolKind.Method, 65SymbolKind.Field, 66SymbolKind.Property, 67SymbolKind.Event);

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

Microsoft.CodeAnalysis.Analyzers.UnitTests (28)

MetaAnalyzers\UnsupportedSymbolKindArgumentRuleTests.cs (28)

Microsoft.CodeAnalysis.AnalyzerUtilities (284)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

212return location.Symbol?.Kind == SymbolKind.Parameter &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\ParameterValidationAnalysis\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

34Debug.Assert(analysisContext.OwningSymbol.Kind == SymbolKind.Method);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\DefaultPointsToValueGenerator.cs (1)

31if (analysisEntity.Symbol?.Kind == SymbolKind.Local ||

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\PointsToAnalysis\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (2)

312if (analysisEntity.Symbol?.Kind == SymbolKind.Field) 1020(symbol.IsReadOnlyFieldOrProperty() || symbol.Kind == SymbolKind.Method) &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AbstractDataFlowAnalysisContext.cs (4)

46Debug.Assert(owningSymbol.Kind is SymbolKind.Method or 47SymbolKind.Field or 48SymbolKind.Property or 49SymbolKind.Event);

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

147result = Symbol.Kind != SymbolKind.Parameter && 148Symbol.Kind != SymbolKind.Local &&

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

692entity.Symbol?.Kind == SymbolKind.Local &&

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\AnalysisEntityFactory.cs (10)

313Debug.Assert(symbol.Kind is SymbolKind.Local or SymbolKind.Parameter or SymbolKind.Field or SymbolKind.Property); 448symbol?.Kind != SymbolKind.Local && 449symbol?.Kind != SymbolKind.Parameter) 519Debug.Assert(symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter || symbol.IsStatic || symbol.IsLambdaOrLocalFunction()); 534(symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter))

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

232=> entity.Symbol?.Kind is SymbolKind.Field or SymbolKind.Property;

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

1141Debug.Assert(parameterEntity.Symbol?.Kind == SymbolKind.Parameter); 2616if (capturedVariable.Kind == SymbolKind.NamedType)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (302)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

SymbolIsBannedAnalyzerBase.cs (5)

63SymbolKind.NamedType, 64SymbolKind.Method, 65SymbolKind.Field, 66SymbolKind.Property, 67SymbolKind.Event);

Microsoft.CodeAnalysis.CodeStyle (225)

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

58context.RegisterSymbolAction(AnalyzeFieldSymbol, SymbolKind.Field); 81}, SymbolKind.NamedType);

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

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

src\Analyzers\Core\Analyzers\QualifyMemberAccess\AbstractQualifyMemberAccessDiagnosticAnalyzer.cs (1)

106var symbolKind = operation switch

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

781case SymbolKind.NamedType: 782case SymbolKind.Method: 783case SymbolKind.Field: 784case SymbolKind.Property: 785case SymbolKind.Event:

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

228compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 278}, SymbolKind.NamedType); 808case SymbolKind.Method: 909case SymbolKind.Field: 912case SymbolKind.Property: 920case SymbolKind.Event:

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

606(symbol.IsStatic && symbol.Kind == SymbolKind.Local) ||

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

112case SymbolKind.Namespace: 113case SymbolKind.NamedType: 114case SymbolKind.Field: 115case SymbolKind.Parameter: 116case SymbolKind.Local:

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

287if (symbolInfo.Symbol.Kind != SymbolKind.Method)

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

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Microsoft.CodeAnalysis.CodeStyle.Fixes (68)

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

551if (parameterType.Kind == SymbolKind.TypeParameter)

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

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

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

71var parameterNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Parameter, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false);

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

143var fieldNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Field, Accessibility.Private, cancellationToken).ConfigureAwait(false); 144var propertyNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Property, Accessibility.Public, cancellationToken).ConfigureAwait(false); 145var parameterNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Parameter, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false);

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

194if (semanticInfo.GetAllSymbols().Any(static s => s.Kind is SymbolKind.Local or SymbolKind.Parameter) &&

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

100document.Document, state, SymbolKind.Property, state.DetermineMaximalAccessibility(), cancellationToken).ConfigureAwait(false)) 116Document document, State state, SymbolKind kind, Accessibility accessibility, CancellationToken cancellationToken) 182document, state, SymbolKind.Local, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false)) 198document, state, SymbolKind.Parameter, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false))

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (6)

139.Where(m => m.Kind != SymbolKind.Method); 310CheckSurroundingContext(SymbolKind.Field, cancellationToken); 311CheckSurroundingContext(SymbolKind.Property, cancellationToken); 317SymbolKind symbolKind, CancellationToken cancellationToken) 348if (symbolKind == SymbolKind.Field) 362SymbolKind symbolKind,

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

233SymbolKind.Field, Accessibility.Private, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\Naming\FallbackNamingRules.cs (8)

25new SymbolKindOrTypeKind(SymbolKind.Field), 26new SymbolKindOrTypeKind(SymbolKind.Local), 27new SymbolKindOrTypeKind(SymbolKind.Parameter), 28new SymbolKindOrTypeKind(SymbolKind.RangeVariable), 36[new SymbolKindOrTypeKind(SymbolKind.Field)]), 69var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(SymbolKind.Field), new SymbolKindOrTypeKind(SymbolKind.Parameter), new SymbolKindOrTypeKind(SymbolKind.Local));

src\Analyzers\Core\CodeFixes\Naming\NamingExtensions.cs (1)

17this Document document, SymbolKind symbolKind, Accessibility accessibility, CancellationToken cancellationToken)

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (1)

67if (symbol.Kind == SymbolKind.Field)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (15)

src\Features\DiagnosticsTestUtilities\NamingStyles\NamingStylesTestOptionSets.cs (15)

Microsoft.CodeAnalysis.CSharp (1289)

Binder\Binder.cs (14)

427RoslynDebug.Assert(member is null || member.Kind != SymbolKind.ErrorType); 447case SymbolKind.Method: 451case SymbolKind.NamedType: 606case SymbolKind.NamedType: 607case SymbolKind.Field: 608case SymbolKind.Method: 609case SymbolKind.Event: 610case SymbolKind.Property: 643RoslynDebug.Assert(symbol.Kind == SymbolKind.NamedType || 644symbol.Kind == SymbolKind.Field || 645symbol.Kind == SymbolKind.Method || 646symbol.Kind == SymbolKind.Event || 647symbol.Kind == SymbolKind.Property); 651if (symbol.Kind == SymbolKind.Method)

Binder\Binder.IdentifierUsedAsValueFinder.cs (2)

289Debug.Assert(symbol.Kind != SymbolKind.Method); 290treatAsInstanceMemberAccess = !(symbol.IsStatic || symbol.Kind == SymbolKind.NamedType);

Binder\Binder.NamespaceOrTypeOrAliasSymbolWithAnnotations.cs (2)

39internal bool IsAlias => _symbol?.Kind == SymbolKind.Alias; 47Debug.Assert(_symbol?.Kind == SymbolKind.Alias); // Not meaningful to use this property otherwise

Binder\Binder.ValueChecks.cs (5)

1679if (containing.Kind == SymbolKind.Method) 1686else if (containing.Kind == SymbolKind.Field) 1882&& symbol.Kind != SymbolKind.Event 2157Debug.Assert(member.Kind != SymbolKind.Property); 2158Debug.Assert(member.Kind != SymbolKind.Event);

Binder\Binder_AnonymousTypes.cs (4)

124if (symbol.Kind == SymbolKind.Property) 193case SymbolKind.Method: 196case SymbolKind.Field: 199case SymbolKind.NamedType:

Binder\Binder_Attributes.cs (5)

531if (namedArgumentNameSymbol.Kind == SymbolKind.Property) 609if (namedArgumentNameSymbol.Kind == SymbolKind.ErrorType) 628case SymbolKind.Field: 635case SymbolKind.Property: 949case SymbolKind.TypeParameter:

Binder\Binder_Await.cs (2)

160case SymbolKind.Field: 173case SymbolKind.Method:

Binder\Binder_Constraints.cs (2)

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

Binder\Binder_Crefs.cs (11)

53if (result.Kind == SymbolKind.ErrorType) 103if ((object?)containerOpt != null && containerOpt.Kind == SymbolKind.TypeParameter) 501symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 842if (s.Kind != SymbolKind.Method) 865s.Kind != SymbolKind.Method || ((MethodSymbol)s).Arity == 0); 901if (symbol.Kind == SymbolKind.TypeParameter) 916else if (symbol.Kind == SymbolKind.TypeParameter) 971case SymbolKind.Method: 1001case SymbolKind.Property: 1017case SymbolKind.NamedType: 1113if (symbol.Kind == SymbolKind.Method)

Binder\Binder_Expressions.cs (63)

Binder\Binder_Invocation.cs (2)

377else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType) 2141if (parameterType?.Kind == SymbolKind.NamedType &&

Binder\Binder_Lookup.cs (32)

Binder\Binder_NameConflicts.cs (3)

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

Binder\Binder_Operators.cs (1)

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

Binder\Binder_Patterns.cs (6)

562if (strippedInputType.Kind is not SymbolKind.ErrorType and not SymbolKind.DynamicType and not SymbolKind.TypeParameter && 888if ((InConstructorInitializer || InFieldInitializer) && ContainingMemberOrLambda.ContainingSymbol.Kind == SymbolKind.NamedType) 953type.ContainingSymbol is var declContainer && declContainer.Kind == SymbolKind.Namespace && declContainer.Name == "System" && 1492member.Symbol is { Name: WellKnownMemberNames.LengthPropertyName or WellKnownMemberNames.CountPropertyName, Kind: SymbolKind.Property } memberSymbol)

Binder\Binder_Statements.cs (4)

1872if (destinationType.Kind == SymbolKind.ArrayType) 2982return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningTask(this.Compilation); 2988return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningGenericTask(this.Compilation); 2994if (symbol?.Kind == SymbolKind.Method)

Binder\Binder_Symbols.cs (39)

Binder\Binder_XmlNameAttribute.cs (2)

45Debug.Assert(lookupSymbols[0].Kind == SymbolKind.TypeParameter || lookupSymbols[0].Kind == SymbolKind.Parameter);

Binder\BinderFactory.BinderFactoryVisitor.cs (11)

521return (SourceMemberMethodSymbol)GetMemberSymbol(methodName, baseMethodDeclarationSyntax.FullSpan, container, SymbolKind.Method); 540return (SourcePropertySymbol)GetMemberSymbol(propertyName, basePropertyDeclarationSyntax.Span, container, SymbolKind.Property); 557return (SourceEventSymbol)GetMemberSymbol(eventName, eventDeclarationSyntax.Span, container, SymbolKind.Event); 560private Symbol GetMemberSymbol(string memberName, TextSpan memberSpan, NamedTypeSymbol container, SymbolKind kind) 562Debug.Assert(kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event); 592bool checkSymbol(Symbol sym, TextSpan memberSpan, SymbolKind kind, out Symbol result) 601if (kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event)

Binder\ContextualAttributeBinder.cs (3)

58case SymbolKind.Method: 59case SymbolKind.Property: 60case SymbolKind.Event:

Binder\ExecutableCodeBinder.cs (3)

42(memberSymbol.Kind != SymbolKind.Local && memberSymbol.Kind != SymbolKind.RangeVariable && memberSymbol.Kind != SymbolKind.Parameter));

Binder\ForEachLoopBinder.cs (5)

956if (collectionExprType.Kind == SymbolKind.DynamicType && isAsync) 963if (collectionExprType.Kind == SymbolKind.ArrayType || collectionExprType.Kind == SymbolKind.DynamicType) 1412if (member.Kind != SymbolKind.Method) 1701if (lookupSymbol.IsStatic || lookupSymbol.DeclaredAccessibility != Accessibility.Public || lookupSymbol.Kind != SymbolKind.Property)

Binder\HostObjectModeBinder.cs (2)

36if (hostObjectType.Kind == SymbolKind.ErrorType) 55if (hostObjectType.Kind != SymbolKind.ErrorType)

Binder\ImportChain.cs (1)

110if (target.Kind == SymbolKind.Namespace)

Binder\InContainerBinder.cs (2)

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

Binder\InMethodBinder.cs (20)

Binder\LocalBinderFactory.cs (4)

137Debug.Assert(containingMemberOrLambda.Kind != SymbolKind.Local && containingMemberOrLambda.Kind != SymbolKind.RangeVariable && containingMemberOrLambda.Kind != SymbolKind.Parameter); 296=> target.Kind == SymbolKind.Method ? new WithMethodTypeParametersBinder((MethodSymbol)target, enclosing) : null;

Binder\LocalScopeBinder.cs (10)

504SymbolKind newSymbolKind = (object)newSymbol == null ? SymbolKind.Parameter : newSymbol.Kind; 506if (newSymbolKind == SymbolKind.ErrorType) return true; 510declaredInThisScope |= newSymbolKind == SymbolKind.Local && this.Locals.Contains((LocalSymbol)newSymbol); 511declaredInThisScope |= newSymbolKind == SymbolKind.Method && this.LocalFunctions.Contains((LocalFunctionSymbol)newSymbol); 522case SymbolKind.Local: 523case SymbolKind.Parameter: 524case SymbolKind.Method: 525case SymbolKind.TypeParameter: 530case SymbolKind.RangeVariable:

Binder\MethodGroupResolution.cs (1)

50Debug.Assert(((object)otherSymbol == null) || (otherSymbol.Kind != SymbolKind.Method));

Binder\Semantics\AccessCheck.cs (28)

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

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

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

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

1461case SymbolKind.Method: 1463case SymbolKind.Property: 3376if (targetType.Kind != SymbolKind.NamedType) 4778case SymbolKind.Property: 4780case SymbolKind.Method:

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

903Debug.Assert(badMember.Kind == SymbolKind.Method);

Binder\WithLambdaParametersBinder.cs (8)

126SymbolKind newSymbolKind = (object)newSymbol == null ? SymbolKind.Parameter : newSymbol.Kind; 130case SymbolKind.ErrorType: 133case SymbolKind.Parameter: 134case SymbolKind.Local: 139case SymbolKind.Method: 143case SymbolKind.TypeParameter: 147case SymbolKind.RangeVariable:

Binder\WithUsingNamespacesAndTypesBinder.cs (5)

94case SymbolKind.Namespace: 109case SymbolKind.NamedType: 215case SymbolKind.Namespace: 219case SymbolKind.Method: 229case SymbolKind.NamedType:

BoundTree\BoundExpressionExtensions.cs (1)

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

BoundTree\BoundTreeRewriter.cs (11)

122case SymbolKind.Alias: 124case SymbolKind.Discard: 126case SymbolKind.Event: 128case SymbolKind.Label: 130case SymbolKind.Local: 132case SymbolKind.Namespace: 134case SymbolKind.RangeVariable: 136case SymbolKind.Field: 138case SymbolKind.Parameter: 140case SymbolKind.Property: 142case SymbolKind.Method:

BoundTree\UnboundLambda.cs (1)

417bool hasErrors = !types.IsDefault && types.Any(static t => t.Type?.Kind == SymbolKind.ErrorType);

BoundTree\VariablePendingInference.cs (2)

50case SymbolKind.Local: 78case SymbolKind.Field:

Compilation\CSharpCompilation.cs (7)

2462within0.Kind == SymbolKind.Assembly ? 3134if (symbol.Kind == SymbolKind.Method && symbol.IsImplicitlyDeclared && ((MethodSymbol)symbol).MethodKind == MethodKind.Constructor) 3699Debug.Assert(symbol.ContainingSymbol.Kind == SymbolKind.Namespace); // avoid unnecessary traversal of nested types 4831case SymbolKind.Parameter: 4832case SymbolKind.TypeParameter: 4833case SymbolKind.Property: 4834case SymbolKind.Event:

Compilation\CSharpSemanticModel.cs (20)

Compilation\InitializerSemanticModel.cs (6)

150case SymbolKind.Field: 164case SymbolKind.Property: 171case SymbolKind.Parameter: 277case SymbolKind.Field: 278case SymbolKind.Property: 282case SymbolKind.Parameter:

Compilation\MethodBodySemanticModel.cs (1)

52Debug.Assert(owner.Kind == SymbolKind.Method);

Compilation\SyntaxTreeSemanticModel.cs (13)

259Debug.Assert(symbols.All(s => s.Kind == SymbolKind.TypeParameter || s.Kind == SymbolKind.Parameter)); 366if ((object)result == null || result.Kind == SymbolKind.ErrorType) 2465case SymbolKind.Namespace: 2470case SymbolKind.Method: 2475case SymbolKind.NamedType: 2490case SymbolKind.Method: 2511case SymbolKind.NamedType: 2526case SymbolKind.Method: 2539case SymbolKind.NamedType: 2560case ParameterSyntax param when declaredSymbol.Kind == SymbolKind.Property && param.Parent?.Parent is RecordDeclarationSyntax recordDeclaration && recordDeclaration.ParameterList == param.Parent: 2572case SymbolKind.Method: 2596case SymbolKind.NamedType:

Compiler\ClsComplianceChecker.cs (45)

Compiler\DocumentationCommentCompiler.cs (15)

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (7)

562case SymbolKind.Method: 565case SymbolKind.Property: 568case SymbolKind.NamedType: 569case SymbolKind.ErrorType: 590case SymbolKind.NamedType: // Includes delegates. 591case SymbolKind.ErrorType: 598case SymbolKind.Method:

Compiler\MethodBodySynthesizer.cs (1)

600if (member.Kind == SymbolKind.Method)

Compiler\MethodCompiler.cs (4)

521case SymbolKind.NamedType: 525case SymbolKind.Method: 566case SymbolKind.Property: 576case SymbolKind.Field:

Compiler\SynthesizedMetadataCompiler.cs (2)

95case SymbolKind.Property: 96case SymbolKind.NamedType:

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

154if (containingSymbol.Kind == SymbolKind.Method)

Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)

70if (member.Kind == SymbolKind.Field)

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (14)

Emitter\EditAndContinue\EmitHelpers.cs (1)

165if (type.Kind == SymbolKind.ErrorType)

Emitter\Model\NamedTypeSymbolAdapter.cs (4)

328if (member.Kind == SymbolKind.Method) 965if (m.Kind == SymbolKind.Event) 1044if (m.Kind == SymbolKind.Method) 1061if (m.Kind == SymbolKind.Property)

Emitter\Model\PEAssemblyBuilder.cs (1)

649var subnamespace = (NamespaceSymbol)result.GetMembers(partName).FirstOrDefault(m => m.Kind == SymbolKind.Namespace);

Emitter\Model\PEModuleBuilder.cs (25)

Emitter\Model\SymbolAdapter.cs (5)

69(this.Kind == SymbolKind.Assembly && this is SourceAssemblySymbol) || 70(this.Kind == SymbolKind.NetModule && this is SourceModuleSymbol)); 89Debug.Assert(this.Kind != SymbolKind.Assembly); 96Debug.Assert(this.Kind != SymbolKind.Assembly); 152if (this.Kind == SymbolKind.Assembly)

Emitter\Model\TypeParameterSymbolAdapter.cs (4)

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

Emitter\NoPia\EmbeddedEvent.cs (1)

133if (m.Kind == SymbolKind.Method)

Emitter\NoPia\EmbeddedType.cs (4)

300case SymbolKind.Field: 303case SymbolKind.Method: 306case SymbolKind.Property: 309case SymbolKind.Event:

Emitter\NoPia\EmbeddedTypesManager.cs (3)

271if (member.Kind != SymbolKind.NamedType) 513case SymbolKind.Property: 516case SymbolKind.Event:

Errors\MessageProvider.cs (2)

101if (symbol.Kind == SymbolKind.Assembly || symbol.Kind == SymbolKind.Namespace)

FlowAnalysis\AbstractFlowPass.cs (1)

3622if (node.MemberSymbol?.Kind == SymbolKind.Property)

FlowAnalysis\DataFlowsInWalker.cs (1)

110_dataFlowsIn.Add(symbol.Kind == SymbolKind.Field ? GetNonMemberSymbol(slot) : symbol);

FlowAnalysis\DataFlowsOutWalker.cs (1)

258_dataFlowsOut.Add(symbol.Kind == SymbolKind.Field ? GetNonMemberSymbol(slot) : symbol);

FlowAnalysis\DefiniteAssignment.cs (18)

289Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event, 495bool hasAssociatedProperty = associatedPropertyOrEvent?.Kind == SymbolKind.Property; 693Debug.Assert(captured.Kind == SymbolKind.Parameter || captured.Kind == SymbolKind.Local || captured.Kind == SymbolKind.RangeVariable); 729else if (variable.Kind != SymbolKind.RangeVariable) 773if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 855if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 1217symbol.Kind == SymbolKind.Local && 1230if (symbol.Kind == SymbolKind.Field) 1234else if (symbol.Kind == SymbolKind.Parameter && 1310var hasAssociatedProperty = associatedSymbol?.Kind == SymbolKind.Property; 1808while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property) 2663if (symbol.Kind != SymbolKind.Field)

FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (1)

162if (symbol.Kind == SymbolKind.Method &&

FlowAnalysis\DefiniteAssignment.VariableIdentifier.cs (7)

30SymbolKind.Local => true, 31SymbolKind.Parameter => true, 32SymbolKind.Field => true, 33SymbolKind.Property => true, 34SymbolKind.Event => true, 35SymbolKind.ErrorType => true, 36SymbolKind.Method when symbol is MethodSymbol m && m.MethodKind == MethodKind.LocalFunction => true,

FlowAnalysis\DefinitelyAssignedWalker.cs (1)

96symbol.Kind != SymbolKind.Field)

FlowAnalysis\EmptyStructTypeCache.cs (3)

196case SymbolKind.Field: 208case SymbolKind.Event: 255for (; symbol != null && symbol.Kind != SymbolKind.Namespace; symbol = symbol.ContainingSymbol)

FlowAnalysis\LocalDataFlowPass.cs (1)

105if (symbol.Kind == SymbolKind.RangeVariable) return -1;

FlowAnalysis\NullableWalker.cs (28)

FlowAnalysis\NullableWalker_Patterns.cs (2)

264if (member.Symbol.Kind is not (SymbolKind.Property or SymbolKind.Field))

FlowAnalysis\ReadWriteWalker.cs (4)

81while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property) 133if (variable.Kind != SymbolKind.Field) (IsInside ? _readInside : _readOutside).Add(variable);

FlowAnalysis\UnassignedVariablesWalker.cs (1)

59if (symbol.Kind != SymbolKind.Field)

FlowAnalysis\VariablesDeclaredWalker.cs (1)

79if (p.Variable?.Kind == SymbolKind.Local)

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (2)

479if (member.Kind != SymbolKind.Method) 507if (member.Kind != SymbolKind.Property)

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (2)

212if (member.Kind == SymbolKind.Property) 267if (member.Kind == SymbolKind.Method)

Lowering\ClosureConversion\ClosureConversion.Analysis.cs (3)

579case SymbolKind.Parameter: 580case SymbolKind.Local: 587case SymbolKind.Method:

Lowering\ClosureConversion\ClosureConversion.Analysis.Tree.cs (7)

609symbol.Kind == SymbolKind.Local || 610symbol.Kind == SymbolKind.Parameter || 611symbol.Kind == SymbolKind.Method); 657if (symbol.Kind == SymbolKind.Method) 685case SymbolKind.Local: 688case SymbolKind.Parameter: 694Debug.Assert(capturedVariable.Kind == SymbolKind.Method);

Lowering\ClosureConversion\ClosureConversion.cs (2)

757case SymbolKind.Parameter: 768case SymbolKind.Local:

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (9)

913case SymbolKind.Field: 915case SymbolKind.Property: 917case SymbolKind.Event: 928case SymbolKind.Field: 930case SymbolKind.Property: 932case SymbolKind.Event: 963builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 972builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ? 981builder.Add(_bound.StaticCall(sym.Kind is SymbolKind.Property ?

Lowering\DiagnosticsPass_ExpressionTrees.cs (2)

208Debug.Assert(symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter || symbol is LocalFunctionSymbol);

Lowering\Instrumentation\LocalStateTracingInstrumenter.cs (1)

206var enumDelta = (targetSymbol.Kind == SymbolKind.Parameter) ?

Lowering\LocalRewriter\LocalRewriter_BinaryOperator.cs (1)

2119if (exprType.Kind == SymbolKind.TypeParameter)

Lowering\LocalRewriter\LocalRewriter_Call.cs (1)

706refKind = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter ? RefKind.Ref : RefKind.None;

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (5)

263Debug.Assert(propertyOrEvent.Kind == SymbolKind.Property || propertyOrEvent.Kind == SymbolKind.Event); 312var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter; 592Debug.Assert(fieldOrEvent.Kind == SymbolKind.Field || fieldOrEvent.Kind == SymbolKind.Event);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

45if (nodeExpressionType.Kind == SymbolKind.ArrayType)

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (1)

84if (argumentType.Kind == SymbolKind.TypeParameter)

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)

710case SymbolKind.Field: 714case SymbolKind.Property: 743case SymbolKind.Event:

Lowering\MethodToClassRewriter.cs (2)

364case SymbolKind.Field: 367case SymbolKind.Property:

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (8)

168case SymbolKind.Local: 175case SymbolKind.Parameter: 179case SymbolKind.Field: 230var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type; 281case SymbolKind.Field: 283goto case SymbolKind.Local; 285case SymbolKind.Local: 286case SymbolKind.Parameter:

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

181Debug.Assert(localOrParameter.Kind == SymbolKind.Local || localOrParameter.Kind == SymbolKind.Parameter);

Lowering\StateMachineRewriter\StateMachineRewriter.cs (3)

153Debug.Assert(variable.Kind == SymbolKind.Local || variable.Kind == SymbolKind.Parameter); 155if (variable.Kind == SymbolKind.Local)

Lowering\SynthesizedSubmissionFields.cs (1)

64if ((object)hostObjectTypeSymbol != null && hostObjectTypeSymbol.Kind != SymbolKind.ErrorType)

Lowering\SyntheticBoundNodeFactory.cs (1)

1791if (exprType.Kind == SymbolKind.TypeParameter)

Operations\CSharpOperationFactory.cs (3)

869case SymbolKind.Field: 873case SymbolKind.Event: 876case SymbolKind.Property:

SymbolDisplay\SymbolDisplayVisitor.cs (4)

108text = EscapeIdentifier(text, symbol?.Kind is SymbolKind.NamedType or SymbolKind.Alias); 383if (symbol.Kind != SymbolKind.Method) 465&& symbol.Kind == SymbolKind.Field

SymbolDisplay\SymbolDisplayVisitor.Types.cs (4)

52while (underlyingType.Kind == SymbolKind.ArrayType && !ShouldAddNullableAnnotation(underlyingType)); 824if (owner.Kind == SymbolKind.Method) 851if (typeArg.Kind == SymbolKind.TypeParameter) 889if (typeArg.Kind == SymbolKind.TypeParameter)

Symbols\AbstractTypeMap.cs (7)

101case SymbolKind.NamedType: 104case SymbolKind.TypeParameter: 106case SymbolKind.ArrayType: 109case SymbolKind.PointerType: 112case SymbolKind.FunctionPointerType: 115case SymbolKind.DynamicType: 118case SymbolKind.ErrorType:

Symbols\AliasSymbol.cs (3)

83if (previousTarget.Kind != SymbolKind.Namespace) 101public override SymbolKind Kind 105return SymbolKind.Alias;

Symbols\AnonymousTypes\AnonymousTypeManager.Templates.cs (1)

746if (member.Kind == SymbolKind.Method)

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.TemplateSymbol.cs (1)

119case SymbolKind.Field:

Symbols\ArrayTypeSymbol.cs (2)

287public override SymbolKind Kind 291return SymbolKind.ArrayType;

Symbols\AssemblySymbol.cs (2)

201public sealed override SymbolKind Kind 205return SymbolKind.Assembly;

Symbols\Attributes\AttributeData.cs (20)

Symbols\Attributes\SourceAttributeData.cs (2)

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

Symbols\BaseTypeAnalysis.cs (2)

186case SymbolKind.Field: 191case SymbolKind.Event:

Symbols\Compilation_WellKnownMembers.cs (20)

Symbols\ConstraintsHelper.cs (2)

589if (type.Kind == SymbolKind.NamedType) 593else if (type.Kind == SymbolKind.PointerType)

Symbols\DiscardSymbol.cs (2)

31public override SymbolKind Kind => SymbolKind.Discard;

Symbols\DynamicTypeSymbol.cs (2)

55public override SymbolKind Kind 59return SymbolKind.DynamicType;

Symbols\ErrorTypeSymbol.cs (2)

221public sealed override SymbolKind Kind 225return SymbolKind.ErrorType;

Symbols\EventSymbol.cs (2)

239public sealed override SymbolKind Kind 243return SymbolKind.Event;

Symbols\ExtendedErrorTypeSymbol.cs (6)

36(containingSymbol.Kind == SymbolKind.Namespace) || 37(containingSymbol.Kind == SymbolKind.NamedType) || 38(containingSymbol.Kind == SymbolKind.ErrorType)); 316case SymbolKind.NamedType: 317case SymbolKind.ErrorType: 319case SymbolKind.Method:

Symbols\FieldSymbol.cs (2)

186public sealed override SymbolKind Kind 190return SymbolKind.Field;

Symbols\FunctionPointers\FunctionPointerTypeSymbol.cs (2)

79public override SymbolKind Kind => SymbolKind.FunctionPointerType;

Symbols\FunctionTypeSymbol.cs (1)

108public override SymbolKind Kind => SymbolKindInternal.FunctionType;

Symbols\LabelSymbol.cs (3)

162/// Returns value 'Label' of the <see cref="SymbolKind"/> 164public override SymbolKind Kind 168return SymbolKind.Label;

Symbols\LocalSymbol.cs (3)

187/// Returns value 'Local' of the <see cref="SymbolKind"/> 189public sealed override SymbolKind Kind 193return SymbolKind.Local;

Symbols\MemberSignatureComparer.cs (5)

524if (member.Kind != SymbolKind.Field) 832case SymbolKind.Method: 834case SymbolKind.Property: //NOTE: Not using PropertySymbol.CallingConvention 835case SymbolKind.Event: 844return member.Kind == SymbolKind.Method && ((MethodSymbol)member).IsVararg;

Symbols\MemberSymbolExtensions.cs (72)

Symbols\MergedNamespaceSymbol.cs (1)

142if (childSymbol.Kind == SymbolKind.Namespace)

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

153case SymbolKind.ErrorType: 154case SymbolKind.NamedType: 163case SymbolKind.ArrayType: 166case SymbolKind.PointerType: 169case SymbolKind.FunctionPointerType: 172case SymbolKind.DynamicType:

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

218case SymbolKind.TypeParameter: 221case SymbolKind.ArrayType: 224case SymbolKind.PointerType: 227case SymbolKind.DynamicType: 230case SymbolKind.ErrorType: 231goto case SymbolKind.NamedType; 232case SymbolKind.NamedType: 316Debug.Assert(ReferenceEquals(newresult, result) || (newresult.Kind == SymbolKind.ErrorType)); 544Debug.Assert(scope.Kind == SymbolKind.NamedType || scope.Kind == SymbolKind.ErrorType);

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

653return candidate.Kind != SymbolKind.ErrorType || !(candidate is MissingMetadataTypeSymbol);

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

579while (s.Kind != SymbolKind.Namespace) 1206if (staticIndex < staticFields.Length && staticFields[staticIndex].Kind == SymbolKind.Field) 1222Debug.Assert(staticIndex == staticFields.Length || staticFields[staticIndex].Kind != SymbolKind.Field); 1234IEnumerable<FieldSymbol> nonEventFields = GetMembers<FieldSymbol>(this.GetMembers().WhereAsArray(m => !(m is TupleErrorFieldSymbol)), SymbolKind.Field, offset: 0); 1307int index = GetIndexOfFirstMember(members, SymbolKind.Method); 1313if (members[index].Kind != SymbolKind.Method) 1331if (index >= members.Length || members[index].Kind != SymbolKind.Method) 1359if (index == members.Length || members[index].Kind != SymbolKind.Method) 1399return GetMembers<PropertySymbol>(this.GetMembers(), SymbolKind.Property); 1404return GetMembers<EventSymbol>(this.GetMembers(), SymbolKind.Event); 1521Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder()); 1522Debug.Assert(SymbolKind.Method.ToSortOrder() < SymbolKind.Property.ToSortOrder()); 1523Debug.Assert(SymbolKind.Property.ToSortOrder() < SymbolKind.Event.ToSortOrder()); 1524Debug.Assert(SymbolKind.Event.ToSortOrder() < SymbolKind.NamedType.ToSortOrder()); 1620Debug.Assert(field.AssociatedSymbol.Kind == SymbolKind.Event); 1692if (member.Kind == SymbolKind.NamedType) 2831private static int GetIndexOfFirstMember(ImmutableArray<Symbol> members, SymbolKind kind) 2848private static IEnumerable<TSymbol> GetMembers<TSymbol>(ImmutableArray<Symbol> members, SymbolKind kind, int offset = -1)

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

316var accessSymbol = containingSymbol.Kind == SymbolKind.Property ? containingSymbol.ContainingSymbol : containingSymbol;

Symbols\Metadata\PE\PETypeParameterSymbol.cs (4)

106return this.ContainingSymbol.Kind == SymbolKind.Method 253if (_containingSymbol.Kind == SymbolKind.Method) 609var typeParameters = (_containingSymbol.Kind == SymbolKind.Method) ? 670bool inherited = (_containingSymbol.Kind == SymbolKind.Method) && ((MethodSymbol)_containingSymbol).IsOverride;

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

93if (arg.Key.Kind == SymbolKind.ErrorType &&

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

159case SymbolKind.ErrorType: 163case SymbolKind.DynamicType: 164case SymbolKind.TypeParameter: 167case SymbolKind.FunctionPointerType: 170case SymbolKind.PointerType: 173case SymbolKind.NamedType: 196case SymbolKind.ArrayType:

Symbols\MetadataOrSourceAssemblySymbol.cs (2)

97(corType.Kind == SymbolKind.ErrorType && 98_lazySpecialTypes[(int)typeId].Kind == SymbolKind.ErrorType));

Symbols\MethodSymbol.cs (3)

640/// Returns value 'Method' of the <see cref="SymbolKind"/> 642public sealed override SymbolKind Kind 646return SymbolKind.Method;

Symbols\MethodSymbolExtensions.cs (6)

107case SymbolKind.ErrorType: 108case SymbolKind.NamedType: 109case SymbolKind.Method: 110case SymbolKind.Property: 112case SymbolKind.Field: 113case SymbolKind.Event: // Events are not covered by CSemanticChecker::FindSymHiddenByMethPropAgg.

Symbols\MissingMetadataTypeSymbol.cs (1)

255if (symbol.Kind == SymbolKind.Namespace) // VB should also check name casing.

Symbols\MissingNamespaceSymbol.cs (1)

68if (_containingSymbol.Kind == SymbolKind.NetModule)

Symbols\ModuleSymbol.cs (3)

56/// Returns value 'NetModule' of the <see cref="SymbolKind"/> 58public sealed override SymbolKind Kind 62return SymbolKind.NetModule;

Symbols\NamedTypeSymbol.cs (7)

320if (candidate.Kind == SymbolKind.Property) 355if (member.Kind == SymbolKind.Method) 750case SymbolKind.Field: 751case SymbolKind.Event: 805public override SymbolKind Kind // Cannot seal this method because of the ErrorSymbol. 809return SymbolKind.NamedType; 1686ContainingSymbol?.Kind == SymbolKind.Namespace &&

Symbols\NamespaceOrTypeSymbol.cs (2)

44return Kind == SymbolKind.Namespace; 263if (scope.Kind == SymbolKind.ErrorType)

Symbols\NamespaceSymbol.cs (3)

120public sealed override SymbolKind Kind 124return SymbolKind.Namespace; 271if (sym.Kind == SymbolKind.Namespace)

Symbols\ObsoleteAttributeHelpers.cs (1)

63if (symbol.Kind == SymbolKind.Field)

Symbols\OverriddenOrHiddenMembersHelpers.cs (30)

Symbols\ParameterSymbol.cs (2)

267public sealed override SymbolKind Kind 271return SymbolKind.Parameter;

Symbols\PointerTypeSymbol.cs (2)

158public override SymbolKind Kind 162return SymbolKind.PointerType;

Symbols\PropertySymbol.cs (2)

336public sealed override SymbolKind Kind 340return SymbolKind.Property;

Symbols\PublicModel\NamespaceOrTypeSymbol.cs (2)

38bool INamespaceOrTypeSymbol.IsNamespace => UnderlyingSymbol.Kind == SymbolKind.Namespace; 40bool INamespaceOrTypeSymbol.IsType => UnderlyingSymbol.Kind != SymbolKind.Namespace;

Symbols\PublicModel\PreprocessingSymbol.cs (2)

98SymbolKind ISymbol.Kind => SymbolKind.Preprocessing;

Symbols\PublicModel\Symbol.cs (1)

195SymbolKind ISymbol.Kind => UnderlyingSymbol.Kind;

Symbols\RangeVariableSymbol.cs (2)

40public override SymbolKind Kind 44return SymbolKind.RangeVariable;

Symbols\Retargeting\RetargetingNamespaceSymbol.cs (1)

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

Symbols\Retargeting\RetargetingSymbolTranslator.cs (13)

164Debug.Assert(symbol.Kind != SymbolKind.NamedType || ((NamedTypeSymbol)symbol).PrimitiveTypeCode == Cci.PrimitiveTypeCode.NotPrimitive); 227if (type.Kind == SymbolKind.ErrorType) 322if (type.ContainingSymbol.Kind != SymbolKind.NamedType && 494if (newDefinition.Kind == SymbolKind.ErrorType && !newDefinition.IsGenericType) 647case SymbolKind.TypeParameter: 650case SymbolKind.ArrayType: 653case SymbolKind.PointerType: 656case SymbolKind.DynamicType: 659case SymbolKind.ErrorType: 660case SymbolKind.NamedType: 1031if (retargetedMember.Kind == SymbolKind.Method) 1097if (retargetedMember.Kind == SymbolKind.Property) 1116if (retargetedMember.Kind == SymbolKind.Event)

Symbols\Source\ExplicitInterfaceHelpers.cs (2)

316case SymbolKind.Property: 322case SymbolKind.Event:

Symbols\Source\LocalFunctionSymbol.cs (2)

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

Symbols\Source\ModifierUtils.cs (1)

496(symbol.Kind != SymbolKind.Method || (modifiers & DeclarationModifiers.Partial) == 0) &&

Symbols\Source\ParameterHelpers.cs (1)

1104if (current.Kind == SymbolKind.Method)

Symbols\Source\SourceAssemblySymbol.cs (5)

1114if (member.Kind == SymbolKind.Namespace) 2076case SymbolKind.Namespace: 2082case SymbolKind.NamedType: 2238if (forwardedType.Kind != SymbolKind.NamedType) 2733if ((object)associatedPropertyOrEvent != null && associatedPropertyOrEvent.Kind == SymbolKind.Event)

Symbols\Source\SourceEventSymbol.cs (1)

781if (interfaceMember.Kind == SymbolKind.Event && //quick check (necessary, not sufficient)

Symbols\Source\SourceMemberContainerSymbol.cs (31)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (33)

Symbols\Source\SourceMemberFieldSymbol.cs (1)

474if ((object)associatedPropertyOrEvent != null && associatedPropertyOrEvent.Kind == SymbolKind.Event)

Symbols\Source\SourceModuleSymbol.cs (4)

172case SymbolKind.Namespace: 180case SymbolKind.NamedType: 622case SymbolKind.Namespace: 628case SymbolKind.NamedType:

Symbols\Source\SourceNamedTypeSymbol.cs (1)

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

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

769if (imported.Kind == SymbolKind.Namespace) 789else if (imported.Kind == SymbolKind.NamedType) 818else if (imported.Kind is SymbolKind.ArrayType or SymbolKind.PointerType or SymbolKind.FunctionPointerType or SymbolKind.DynamicType) 827else if (imported.Kind != SymbolKind.ErrorType)

Symbols\Source\SourceParameterSymbol.cs (2)

111Debug.Assert((owner.Kind == SymbolKind.Method) || (owner.Kind == SymbolKind.Property) || owner is NamedTypeSymbol { IsExtension: true });

Symbols\SubstitutedNamedTypeSymbol.cs (3)

139public sealed override SymbolKind Kind 250if (t.Kind == SymbolKind.NamedType) 300if (t.Kind == SymbolKind.NamedType)

Symbols\SubstitutedTypeParameterSymbol.cs (1)

65if (_container.Kind == SymbolKind.Method)

Symbols\Symbol.cs (45)

Symbols\Symbol_Attributes.cs (13)

48case SymbolKind.Assembly: 51case SymbolKind.Field: 54case SymbolKind.Method: 66case SymbolKind.NamedType: 94case SymbolKind.NetModule: 97case SymbolKind.Parameter: 100case SymbolKind.Property: 103case SymbolKind.Event: 106case SymbolKind.TypeParameter: 915Debug.Assert(this.Kind == SymbolKind.Method); 934case SymbolKind.Assembly: 935case SymbolKind.NamedType: 936case SymbolKind.Method:

Symbols\SymbolDistinguisher.cs (26)

57case SymbolKind.ErrorType: 58case SymbolKind.NamedType: 59case SymbolKind.Event: 60case SymbolKind.Field: 61case SymbolKind.Method: 62case SymbolKind.Property: 63case SymbolKind.TypeParameter: 65case SymbolKind.ArrayType: 66case SymbolKind.PointerType: 67case SymbolKind.Parameter: 69case SymbolKind.DynamicType: // Can't sensibly append location, but it should never be ambiguous. 70case SymbolKind.FunctionPointerType: // Can't sensibly append location 72case SymbolKind.Namespace: 73case SymbolKind.Alias: 74case SymbolKind.Assembly: 75case SymbolKind.NetModule: 76case SymbolKind.Label: 77case SymbolKind.Local: 78case SymbolKind.RangeVariable: 79case SymbolKind.Preprocessing: 144case SymbolKind.Parameter: 147case SymbolKind.PointerType: 150case SymbolKind.ArrayType: 194Debug.Assert(unwrappedSymbol.Kind == SymbolKind.DynamicType || unwrappedSymbol.Kind == SymbolKind.ErrorType || unwrappedSymbol.Kind == SymbolKind.FunctionPointerType);

Symbols\SymbolExtensions.cs (35)

136case SymbolKind.Namespace: 137case SymbolKind.NamedType: 138case SymbolKind.ErrorType: 147while (containingMember is object && containingMember.Kind == SymbolKind.Method) 166case SymbolKind.Method: 178case SymbolKind.Field: 183case SymbolKind.NamedType: 203case SymbolKind.NamedType: 204case SymbolKind.ErrorType: 207case SymbolKind.Method: 241for (; ((object?)containingSymbol != null) && (containingSymbol.Kind != SymbolKind.Namespace); containingSymbol = containingSymbol.ContainingSymbol) 257case SymbolKind.ArrayType: 258case SymbolKind.DynamicType: 259case SymbolKind.ErrorType: 260case SymbolKind.NamedType: 261case SymbolKind.PointerType: 262case SymbolKind.FunctionPointerType: 263case SymbolKind.TypeParameter: 265case SymbolKind.Alias: 303var upperLevelType = symbol.Kind == SymbolKind.NamedType ? (NamedTypeSymbol)symbol : symbol.ContainingType; 321case SymbolKind.Property: 323case SymbolKind.Event: 336case SymbolKind.NamedType: 338case SymbolKind.Method: 479case SymbolKind.Field: 485case SymbolKind.Method: 491case SymbolKind.Property: 497case SymbolKind.Event: 503case SymbolKind.Local: 509case SymbolKind.Parameter: 515case SymbolKind.ErrorType: 534SymbolKind.Method => ((MethodSymbol)symbol).RequiresInstanceReceiver, 535SymbolKind.Property => ((PropertySymbol)symbol).RequiresInstanceReceiver, 536SymbolKind.Field => ((FieldSymbol)symbol).RequiresInstanceReceiver, 537SymbolKind.Event => ((EventSymbol)symbol).RequiresInstanceReceiver,

Symbols\SymbolKindExtensions.cs (18)

16public static LocalizableErrorArgument Localize(this SymbolKind kind) 20case SymbolKind.Namespace: 22case SymbolKind.NamedType: 24case SymbolKind.TypeParameter: 26case SymbolKind.ArrayType: 28case SymbolKind.PointerType: 30case SymbolKind.FunctionPointerType: 32case SymbolKind.DynamicType: 34case SymbolKind.Method: 36case SymbolKind.Property: 38case SymbolKind.Event: 40case SymbolKind.Field: 42case SymbolKind.Local: 43case SymbolKind.Parameter: 44case SymbolKind.RangeVariable: 46case SymbolKind.Alias: 48case SymbolKind.Label: 50case SymbolKind.Preprocessing:

Symbols\Synthesized\Records\SynthesizedRecordDeconstruct.cs (1)

104if (m.Kind is SymbolKind.Property)

Symbols\Synthesized\Records\SynthesizedRecordPrintMembers.cs (5)

201SymbolKind.Field => F.Field(F.This(), (FieldSymbol)member), 202SymbolKind.Property => F.Property(F.This(), (PropertySymbol)member), 248if (m.Kind is SymbolKind.Field && m is not TupleErrorFieldSymbol) 253if (m.Kind is SymbolKind.Property) 303if (member.Kind != SymbolKind.Property)

Symbols\Synthesized\SynthesizedContainer.cs (2)

60if (ContainingSymbol.Kind == SymbolKind.NamedType && ContainingSymbol.IsImplicitlyDeclared) 133case SymbolKind.Field:

Symbols\Synthesized\SynthesizedSubstitutedTypeParameterSymbol.cs (1)

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

Symbols\Tuples\TupleTypeSymbol.cs (11)

594case SymbolKind.Field: 690case SymbolKind.NamedType: 691case SymbolKind.Method: 692case SymbolKind.Property: 693case SymbolKind.Event: 1015if (member.Kind != SymbolKind.Field) 1062case SymbolKind.Method: 1063case SymbolKind.Property: 1064case SymbolKind.NamedType: 1068case SymbolKind.Field: 1076case SymbolKind.Event:

Symbols\TypeParameterSymbol.cs (2)

188public sealed override SymbolKind Kind 192return SymbolKind.TypeParameter;

Symbols\TypeSymbol.cs (25)

Symbols\TypeSymbolExtensions.cs (19)

268if (type.Kind == SymbolKind.ArrayType) 330return type.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)type).IsInterface; 348return type.Kind == SymbolKind.ErrorType; 353return p.ContainingSymbol.Kind == SymbolKind.Method; 554if (symbol.Kind != SymbolKind.Namespace) 1012for (Symbol s2 = sym2; s2.Kind != SymbolKind.Namespace; s2 = s2.ContainingSymbol) 1747case SymbolKind.Method: 1748case SymbolKind.NamedType: 1749case SymbolKind.ErrorType: 1750case SymbolKind.Field: 1751case SymbolKind.Property: 1752case SymbolKind.Event: 1779if (container.Kind != SymbolKind.Namespace) 1920case SymbolKind.NamedType: 1921case SymbolKind.ErrorType: 1928case SymbolKind.ArrayType: 1935case SymbolKind.PointerType: 1942case SymbolKind.FunctionPointerType: 2277if (type.Kind == SymbolKind.NamedType)

Symbols\TypeUnification.cs (10)

111case SymbolKind.ArrayType: 128case SymbolKind.PointerType: 140case SymbolKind.NamedType: 141case SymbolKind.ErrorType: 182case SymbolKind.TypeParameter: 269case SymbolKind.ArrayType: 271case SymbolKind.PointerType: 273case SymbolKind.NamedType: 274case SymbolKind.ErrorType: 292case SymbolKind.TypeParameter:

Symbols\VarianceSafety.cs (8)

49case SymbolKind.Method: 55case SymbolKind.Property: 58case SymbolKind.Event: 61case SymbolKind.NamedType: 306case SymbolKind.TypeParameter: 333case SymbolKind.ArrayType: 336case SymbolKind.ErrorType: 337case SymbolKind.NamedType:

Utilities\TypeSymbolExtensions.cs (10)

31case SymbolKind.ArrayType: 36case SymbolKind.PointerType: 41case SymbolKind.FunctionPointerType: 45case SymbolKind.ErrorType: 46case SymbolKind.NamedType: 97case SymbolKind.ArrayType: 104case SymbolKind.PointerType: 110case SymbolKind.FunctionPointerType: 128case SymbolKind.ErrorType: 129case SymbolKind.NamedType:

Microsoft.CodeAnalysis.CSharp.CodeStyle (21)

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

91{ Kind: SymbolKind.Local, DeclaringSyntaxReferences: { Length: 1 } syntaxRefs })

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\NamingStyle\CSharpNamingStyleDiagnosticAnalyzer.cs (1)

30if (symbol.IsKind(SymbolKind.Parameter)

src\Analyzers\CSharp\Analyzers\QualifyMemberAccess\CSharpQualifyMemberAccessDiagnosticAnalyzer.cs (2)

55return (containingSymbol.Kind is SymbolKind.Field or SymbolKind.Property) &&

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (1)

147if (symbolInfo.Symbol.IsKind(SymbolKind.Namespace))

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\Extensions\ExpressionSyntaxExtensions.cs (7)

440case SymbolKind.Field: 441case SymbolKind.Local: 442case SymbolKind.Method: 443case SymbolKind.Parameter: 444case SymbolKind.Property: 445case SymbolKind.RangeVariable: 446case SymbolKind.FunctionPointerType:

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

1224return typeInfo.Type?.Kind == SymbolKind.ArrayType; 1232if (symbol?.Kind == SymbolKind.Field)

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true) 281if (semanticModel.GetSymbolInfo(n, cancellationToken).Symbol.IsKind(SymbolKind.Local) == true)

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

src\Analyzers\CSharp\CodeFixes\AddInheritdoc\AddInheritdocCodeFixProvider.cs (3)

56if (symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event)

src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (4)

84if (leftSymbol.Kind is not SymbolKind.Local and 85not SymbolKind.Parameter and 86not SymbolKind.Field and 87not SymbolKind.Property)

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

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

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

84var members = GetMembers(namedType).WhereAsArray(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s));

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

56if (symbol != null && symbol.Kind != SymbolKind.Namespace && model.GetSymbolInfo(namespacePart).Symbol is INamespaceSymbol) 216if (symbol?.Kind == SymbolKind.NamedType)

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

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

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

114if (targetType.Kind == SymbolKind.DynamicType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpSemanticFactsService.cs (2)

49visibleSymbols = visibleSymbols.WhereAsArray(s => !s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter));

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

635if (method.TypeArguments.Any(static t => t.Kind == SymbolKind.ErrorType)) 676if (returnType.Kind == SymbolKind.TypeParameter) 678if (inferredType.Kind != SymbolKind.TypeParameter) 697case SymbolKind.ArrayType: 700case SymbolKind.PointerType: 703case SymbolKind.NamedType: 1826SemanticModel.GetSymbolInfo(identifierName.Identifier).Symbol?.Kind == SymbolKind.Parameter)

Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests (13)

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (13)

Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (2)

CommandLineTests.cs (2)

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

Microsoft.CodeAnalysis.CSharp.EditorFeatures (1)

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (1)

323if (symbol is not { Kind: SymbolKind.Event })

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (76)

Completion\CompletionProviders\DeclarationNameCompletionProviderTests.cs (8)

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (38)

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (8)

39var symbolKindsWithNoCodeBlocks = new HashSet<SymbolKind> 41SymbolKind.Property, 42SymbolKind.NamedType 98Assert.True(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 99Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 111Assert.True(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 112Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 856=> context.RegisterSymbolAction(OnSymbol, SymbolKind.NamedType);

Diagnostics\FixAllProvider\BatchFixerTests.cs (1)

52if (symbol != null && symbol.Kind == SymbolKind.Field)

SymbolKey\SymbolKeyCompilationsTests.cs (2)

104Assert.NotEqual(SymbolKind.ErrorType, symbol01.Kind); 105Assert.NotEqual(SymbolKind.ErrorType, symbol02.Kind);

SymbolKey\SymbolKeyMetadataVsSourceTests.cs (3)

153originalSymbols = [.. originalSymbols.Where(s => !s.IsAccessor() && s.Kind != SymbolKind.Parameter).OrderBy(s => s.Name).Select(s => s)]; 340var originalSymbols = originals.Where(s => !s.IsAccessor() && s.Kind != SymbolKind.Parameter).OrderBy(s => s.Name).ToList(); 424var originalSymbols = originals.Where(s => !s.IsAccessor() && s.Kind != SymbolKind.Parameter).OrderBy(s => s.Name).ToList();

SymbolKey\SymbolKeyTestBase.cs (16)

Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (92)

CodeGen\CodeGenAsyncLocalsTests.cs (1)

976IEnumerable<IGrouping<TypeSymbol, FieldSymbol>> spillFieldsByType = stateMachineClass.GetMembers().Where(m => m.Kind == SymbolKind.Field && m.Name.StartsWith("<>7__wrap", StringComparison.Ordinal)).Cast<FieldSymbol>().GroupBy(x => x.Type);

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

CodeGen\CodeGenDynamicTests.cs (3)

684case SymbolKind.Field: 689case SymbolKind.Method: 703case SymbolKind.Property:

CodeGen\CodeGenRefLocalTests.cs (1)

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

CodeGen\CodeGenTupleTest.cs (36)

CodeGen\EventTests.cs (2)

210Assert.Equal(SymbolKind.Event, @event.Kind); 232Assert.Equal(SymbolKind.Field, associatedField.Kind);

CodeGen\IndexerTests.cs (2)

154var indexer = @class.GetMembers().Where(member => member.Kind == SymbolKind.Property).Cast<PropertySymbol>().Single(); 257Assert.Equal(SymbolKind.Property, indexer.Kind);

Emit\CompilationEmitTests.cs (8)

4260ParentKind = SymbolKind.Assembly, 4329ParentKind = SymbolKind.Assembly, 4379ParentKind = SymbolKind.Assembly, 4440ParentKind = SymbolKind.Assembly, 4457ParentKind = SymbolKind.Assembly, 4503ParentKind = SymbolKind.Assembly, 4560ParentKind = SymbolKind.Assembly, 4577ParentKind = SymbolKind.Assembly,

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (192)

Attributes\AttributeTests_MarshalAs.cs (4)

34foreach (NamedTypeSymbol type in compilation.GlobalNamespace.GetMembers().Where(s => s.Kind == SymbolKind.NamedType)) 36var fields = type.GetMembers().Where(s => s.Kind == SymbolKind.Field); 68foreach (NamedTypeSymbol type in compilation.GlobalNamespace.GetMembers().Where(s => s.Kind == SymbolKind.NamedType)) 70var methods = type.GetMembers().Where(s => s.Kind == SymbolKind.Method);

Attributes\AttributeTests_Security.cs (27)

Attributes\AttributeTests_Synthesized.cs (2)

493foreach (var member in iter.GetMembers().Where(s => s.Kind == SymbolKind.Method)) 1637ParentKind = SymbolKind.Assembly,

Attributes\AttributeTests_Tuples.cs (5)

277case SymbolKind.Method: 285case SymbolKind.NamedType: 289case SymbolKind.Field: 292case SymbolKind.Property: 295case SymbolKind.Event:

Diagnostics\DiagnosticAnalyzerTests.AllInOne.cs (2)

28var symbolKindsWithNoCodeBlocks = new HashSet<SymbolKind>(); 29symbolKindsWithNoCodeBlocks.Add(SymbolKind.Property);

Diagnostics\DiagnosticAnalyzerTests.cs (51)

Diagnostics\GetDiagnosticsTests.cs (2)

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

FlowAnalysis\FlowTestBase.cs (3)

71case SymbolKind.Method: 75case SymbolKind.NamedType: 85case SymbolKind.Namespace:

Semantics\ExtensionTests.cs (17)

104Assert.Equal(SymbolKind.NamedType, symbol.Kind); 34603Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 34652Assert.Equal(SymbolKind.Parameter, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 35771Assert.Equal(SymbolKind.Parameter, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 35804Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 37616Assert.Equal(SymbolKind.Parameter, symbol.Kind); 37637Assert.Equal(SymbolKind.Parameter, symbol.Kind); 51458context.RegisterSymbolAction(handle, SymbolKind.NamedType); 51459context.RegisterSymbolAction(handle, SymbolKind.Parameter); 51460context.RegisterSymbolAction(handle, SymbolKind.TypeParameter); 51461context.RegisterSymbolAction(handle, SymbolKind.Method); 51462context.RegisterSymbolAction(handle, SymbolKind.Property); 51558context.RegisterSymbolStartAction(handleStart, SymbolKind.NamedType); 51559context.RegisterSymbolStartAction(handleStart, SymbolKind.Method); 51560context.RegisterSymbolStartAction(handleStart, SymbolKind.Property); 51561context.RegisterSymbolStartAction(handleStart, SymbolKind.Parameter); 51562context.RegisterSymbolStartAction(handleStart, SymbolKind.TypeParameter);

Semantics\OutVarTests.cs (3)

1164Assert.NotEqual(SymbolKind.Field, symbol.Kind); 1174if (symbol.Kind == SymbolKind.Local) 32734Assert.Equal(SymbolKind.Field, symbol.Kind);

Semantics\PatternMatchingTestBase.cs (5)

194Assert.NotEqual(SymbolKind.Field, symbol.Kind); 204if (symbol.Kind == SymbolKind.Local) 245Assert.Equal(SymbolKind.Field, symbol.Kind); 399Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind); 400Assert.Equal(SymbolKind.ErrorType, typeInfo.ConvertedType.Kind);

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\PatternMatchingTests_ListPatterns.cs (4)

3646Assert.Equal(SymbolKind.Local, symbol.Kind); 3726Assert.Equal(SymbolKind.Local, symbol.Kind); 3741Assert.Equal(SymbolKind.Local, symbol.Kind); 4416Assert.Equal(SymbolKind.Local, symbol.Kind);

Semantics\PatternMatchingTests2.cs (1)

724Assert.Equal(SymbolKind.Local, symbol.Kind);

Semantics\PrimaryConstructorTests.cs (36)

Semantics\RecordTests.cs (27)

Microsoft.CodeAnalysis.CSharp.Features (84)

AddImport\CSharpAddImportFeatureService.cs (2)

348return namespaceOrTypeSymbol.IsKind(SymbolKind.Namespace) 500usingDirective = namespaceOrTypeSymbol.IsKind(SymbolKind.Namespace)

ChangeSignature\CSharpChangeSignatureService.cs (1)

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

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (2)

524Kind: SymbolKind.Property or SymbolKind.Field,

Completion\CompletionProviders\CompletionUtilities.cs (1)

164if (symbol.Kind == SymbolKind.Label &&

Completion\CompletionProviders\DeclarationName\DeclarationNameInfo.cs (28)

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

46if (nameInfo.PossibleSymbolKinds.Any(static k => k.SymbolKind == SymbolKind.Parameter)) 299result.Add((overloadParameter.Name, NameDeclarationInfo.GetGlyph(SymbolKind.Parameter, declarationInfo.DeclaredAccessibility))); 323=> symbol.Kind is SymbolKind.Local or SymbolKind.Parameter or SymbolKind.RangeVariable;

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

295if (symbol?.Kind == SymbolKind.Field &&

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

140member.Kind == SymbolKind.NamedType ||

Completion\CompletionProviders\PropertySubPatternCompletionProvider.cs (2)

146if (symbol.IsKind(SymbolKind.Field)) 151if (symbol.IsKind(SymbolKind.Property) && !((IPropertySymbol)symbol).IsWriteOnly)

Completion\CompletionProviders\SymbolCompletionProvider.cs (2)

249if (symbol.IsKind(SymbolKind.Method) && !context.IsNameOfContext) 257else if (symbol.IsKind(SymbolKind.NamedType) || symbol is IAliasSymbol aliasSymbol && aliasSymbol.Target.IsType)

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

39new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)

87new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

Debugging\CSharpProximityExpressionsService.cs (1)

72if (info.Symbol.Kind == SymbolKind.Local)

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (1)

1008return symbol.Kind == SymbolKind.Method && syntax is TypeDeclarationSyntax { ParameterList: { } parameterList } ? parameterList : syntax;

GenerateType\CSharpGenerateTypeService.cs (4)

205!leftSymbol.IsKind(SymbolKind.Namespace) || 249if (leftSymbol != null && leftSymbol.IsKind(SymbolKind.Namespace)) 431return memberGroup.ElementAt(0).IsKind(SymbolKind.Method) ? (IMethodSymbol)memberGroup.ElementAt(0) : null; 441if (expressionSymbol.IsKind(SymbolKind.Method))

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (3)

80string.Format(fieldOrProperty.Kind == SymbolKind.Field ? FeaturesResources.Initialize_field_0 : FeaturesResources.Initialize_property_0, fieldOrProperty.Name), 219if (rule.SymbolSpecification.AppliesTo(SymbolKind.Field, Accessibility.Private)) 242if (rule.SymbolSpecification.AppliesTo(SymbolKind.Property, Accessibility.Public))

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

254if (symbol is IMethodSymbol { ContainingSymbol.Kind: SymbolKind.Method } method)

NavigationBar\CSharpNavigationBarItemService.cs (3)

77member.Kind == SymbolKind.NamedType || 178if (member.Kind == SymbolKind.Method) 257if (symbol.Kind == SymbolKind.Field)

Rename\CSharpRenameIssuesService.cs (1)

28symbol.Kind == SymbolKind.DynamicType)

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

31if (expressionSymbol.IsKind(SymbolKind.Event) &&

Snippets\CSharpForEachLoopSnippetProvider.cs (4)

71symbol.Kind is SymbolKind.Local or SymbolKind.Field or SymbolKind.Parameter or SymbolKind.Property);

src\Analyzers\CSharp\Analyzers\ConvertSwitchStatementToExpression\ConvertSwitchStatementToExpressionDiagnosticAnalyzer.Analyzer.cs (1)

91{ Kind: SymbolKind.Local, DeclaringSyntaxReferences: { Length: 1 } syntaxRefs })

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\NamingStyle\CSharpNamingStyleDiagnosticAnalyzer.cs (1)

30if (symbol.IsKind(SymbolKind.Parameter)

src\Analyzers\CSharp\Analyzers\QualifyMemberAccess\CSharpQualifyMemberAccessDiagnosticAnalyzer.cs (2)

55return (containingSymbol.Kind is SymbolKind.Field or SymbolKind.Property) &&

src\Analyzers\CSharp\Analyzers\RemoveUnnecessaryNullableDirective\NullableImpactingSpanWalker.cs (1)

147if (symbolInfo.Symbol.IsKind(SymbolKind.Namespace))

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\AddInheritdoc\AddInheritdocCodeFixProvider.cs (3)

56if (symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event)

src\Analyzers\CSharp\CodeFixes\DisambiguateSameVariable\CSharpDisambiguateSameVariableCodeFixProvider.cs (4)

84if (leftSymbol.Kind is not SymbolKind.Local and 85not SymbolKind.Parameter and 86not SymbolKind.Field and 87not SymbolKind.Property)

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

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

Microsoft.CodeAnalysis.CSharp.Features.UnitTests (18)

ConvertAutoPropertyToFullProperty\ConvertAutoPropertyToFullPropertyTests_OptionSets.cs (3)

77[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)], 109[new SymbolKindOrTypeKind(SymbolKind.Field)], 141[new SymbolKindOrTypeKind(SymbolKind.Field)],

ConvertTupleToStruct\ConvertTupleToStructTests.cs (1)

305[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Parameter)],

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

1518}, SymbolKind.NamedType);

src\Analyzers\CSharp\Tests\NamingStyles\NamingStylesTests.cs (13)

Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests (1)

IOperation\IOperationTests_IVariableDeclaration.cs (1)

943Assert.Equal(SymbolKind.Method, invocInfo.Symbol.Kind);

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (266)

Semantics\ColorColorTests.cs (83)

Semantics\DeconstructionTests.cs (28)

Semantics\ExpressionBodiedMemberTests.cs (4)

141Assert.Equal(SymbolKind.Parameter, semanticInfo.Symbol.Kind); 159Assert.Equal(SymbolKind.Parameter, semanticInfo.Symbol.Kind); 174Assert.Equal(SymbolKind.Parameter, semanticInfo.Symbol.Kind); 267Assert.Equal(SymbolKind.Parameter, semanticInfo.Symbol.Kind);

Semantics\ForEachTests.cs (2)

1221Assert.Equal(SymbolKind.ArrayType, ((BoundConversion)boundNode.Expression).Operand.Type.Kind); 1715Assert.Equal(SymbolKind.DynamicType, ((BoundConversion)boundNode.Expression).Operand.Type.Kind);

Semantics\ImplicitlyTypeArraysTests.cs (2)

69Assert.Equal(SymbolKind.Local, sym.Symbol.Kind); 97Assert.Equal(SymbolKind.ArrayType, symInfo.Symbol.Kind);

Semantics\InteractiveSemanticModelTests.cs (6)

144Assert.Equal(SymbolKind.Field, symbol.Kind); 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); 267Assert.Equal(SymbolKind.RangeVariable, semanticInfo.Symbol.Kind);

Semantics\InteractiveUsingTests.cs (3)

44Assert.Equal(SymbolKind.Property, GetSpeculativeSymbol(sub, "NewLine").Kind); 90Assert.Equal(SymbolKind.Alias, aliasSymbol.Kind); 120Assert.Equal(SymbolKind.Alias, aliasSymbol.Kind);

Semantics\LambdaDiscardParametersTests.cs (5)

453Assert.Equal(SymbolKind.Local, localSymbol.Kind); 457Assert.Equal(SymbolKind.Parameter, parameterSymbol.Kind); 486Assert.Equal(SymbolKind.Local, localSymbol.Kind); 518Assert.Equal(SymbolKind.Local, localSymbol.Kind); 522Assert.Equal(SymbolKind.Local, parameterSymbol.Kind);

Semantics\LambdaTests.cs (4)

856Assert.Equal(SymbolKind.Method, sym.Kind); 866Assert.Equal(SymbolKind.Method, sym.Kind); 3008Assert.Equal(SymbolKind.Parameter, symbol.Kind); 3016Assert.Equal(SymbolKind.Parameter, symbol.Kind);

Semantics\LocalFunctionTests.cs (18)

Semantics\LookupTests.cs (11)

Semantics\NamedAndOptionalTests.cs (1)

819Assert.Equal(SymbolKind.Parameter, symInfo.Symbol.Kind);

Semantics\NativeIntegerTests.cs (14)

Semantics\NonTrailingNamedArgumentsTests.cs (2)

54Assert.Equal(SymbolKind.Parameter, firstASymbol.Symbol.Kind); 66Assert.Equal(SymbolKind.Parameter, secondASymbol.Symbol.Kind);

Semantics\NullableReferenceTypesTests.cs (5)

71853Assert.Equal(SymbolKind.Discard, discard1.Kind); 71857Assert.Equal(SymbolKind.Discard, discard2.Kind); 71861Assert.Equal(SymbolKind.Discard, discard3.Kind); 71865Assert.Equal(SymbolKind.Discard, discard4.Kind); 71869Assert.Equal(SymbolKind.Discard, discard5.Kind);

Semantics\OperatorTests.cs (1)

8409isChecked = isDynamic || symbol1.ContainingSymbol.Kind == SymbolKind.PointerType || symbol1.ContainingType.EnumUnderlyingTypeOrSelf().SpecialType.IsIntegralType();

Semantics\QueryTests.cs (18)

Semantics\RecordStructTests.cs (21)

Semantics\RefFieldTests.cs (1)

2046var fieldMembers = containingType.GetMembers().WhereAsArray(m => m.Kind == SymbolKind.Field);

Semantics\RefLocalsAndReturnsTests.cs (2)

4867Assert.Equal(SymbolKind.DynamicType, model.GetTypeInfo(left).Type.Kind); 4895Assert.Equal(SymbolKind.DynamicType, model.GetTypeInfo(left).Type.Kind);

Semantics\ScriptSemanticsTests.cs (1)

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

Semantics\TopLevelStatementsTests.cs (22)

Semantics\UnsafeTests.cs (8)

Semantics\UsingStatementTests.cs (3)

64Assert.Equal(SymbolKind.Local, declaredSymbol.Kind); 1870Assert.Equal(SymbolKind.Local, symbol.Kind); 1897Assert.Equal(SymbolKind.Local, actualSymbol.Kind);

SourceGeneration\GeneratorDriverTests.cs (1)

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

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (955)

Compilation\CompilationAPITests.cs (1)

1197Assert.Equal(SymbolKind.Assembly, smb.Kind);

Compilation\GetSemanticInfoTests.cs (19)

Compilation\GetUnusedImportDirectivesTests.cs (2)

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

Compilation\IndexedProperties_BindingTests.cs (6)

42IndexedPropertiesBindingChecks(source, reference, SymbolKind.Method, "get_P1"); 63IndexedPropertiesBindingChecks(source, reference, SymbolKind.Property, "P1"); 84IndexedPropertiesBindingChecks(source, reference, SymbolKind.Property, "P1"); 104IndexedPropertiesBindingChecks(source, reference, SymbolKind.Property, "P1"); 130IndexedPropertiesBindingChecks(source, reference, SymbolKind.Property, "P1"); 133private void IndexedPropertiesBindingChecks(string source, MetadataReference reference, SymbolKind symbolKind, string name)

Compilation\SemanticModelAPITests.cs (45)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (36)

Compilation\SemanticModelGetSemanticInfoTests.cs (301)

CrossLanguageTests.cs (2)

38Assert.Empty(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Method && !x.CanBeReferencedByName)); 39Assert.False(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Property).First().CanBeReferencedByName); //there's only one.

DeclarationTests.cs (1)

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

DocumentationComments\CrefTests.cs (11)

DocumentationComments\DocumentationCommentIDTests.cs (19)

SymbolDisplay\SymbolDisplayTests.cs (4)

2424GetMembers("E").Where(m => m.Kind == SymbolKind.Event).Single(); 2477GetMembers("E").Where(m => m.Kind == SymbolKind.Event).Single(); 5805var indexer = type.GetMembers().Where(m => m.Kind == SymbolKind.Property && ((IPropertySymbol)m).IsIndexer).Single(); 6009var indexer = type.GetMembers().Where(m => m.Kind == SymbolKind.Property && ((IPropertySymbol)m).IsIndexer).Single();

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (1)

878var mems = tsym.GetMembers().Where(s => s.Kind == SymbolKind.Method);

Symbols\AnonymousTypesSemanticsTests.cs (10)

Symbols\AssemblyAndNamespaceTests.cs (2)

37Assert.Equal(SymbolKind.Assembly, sym.Kind); 64Assert.Equal(SymbolKind.NetModule, sym.Kind);

Symbols\CompilationCreationTests.cs (115)

Symbols\ConversionTests.cs (2)

2143Assert.Equal(SymbolKind.Method, symbol.Kind); 2177Assert.Equal(SymbolKind.Method, symbol.Kind);

Symbols\ExtensionMethodTests.cs (2)

3154Assert.Equal(SymbolKind.Method, firstInvocationSymbol.Kind); 3160Assert.Equal(SymbolKind.Method, secondInvocationSymbol.Kind);

Symbols\IndexerTests.cs (3)

141var typeAProperties = type.GetMembers().Where(m => m.Kind == SymbolKind.Property).Cast<PropertySymbol>().ToArray(); 1233var classCIndexer = classC.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single(); 1245var classCIndexer = classC.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single();

Symbols\Metadata\MetadataMemberTests.cs (8)

156Assert.Equal(SymbolKind.Assembly, mscorNS.Kind); 163Assert.Equal(SymbolKind.Method, ctor.Kind); 191Assert.Equal(SymbolKind.Assembly, mscorNS.Kind); 204Assert.Equal(SymbolKind.Method, member1.Kind); 243Assert.Equal(SymbolKind.Assembly, mscorNS.Kind); 262Assert.Equal(SymbolKind.Parameter, p1.Kind); 311Assert.Equal(SymbolKind.Method, member1.Kind); 359Assert.Equal(SymbolKind.Parameter, p2.Kind);

Symbols\Metadata\MetadataTypeTests.cs (10)

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

Symbols\Metadata\PE\LoadingEvents.cs (4)

75Assert.Equal(SymbolKind.Event, instanceEvent.Kind); 84Assert.Equal(SymbolKind.Event, staticEvent.Kind); 334var outerInterfaceEvent = outerInterface.GetMembers().Single(m => m.Kind == SymbolKind.Event); 344var innerInterfaceEvent = innerInterface.GetMembers().Single(m => m.Kind == SymbolKind.Event);

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

57Assert.Equal(SymbolKind.Field, f1.Kind); 109Assert.Equal(SymbolKind.NamedType, csFields.GetMembers("FFF").Single().Kind); 110Assert.Equal(SymbolKind.Field, csFields.GetMembers("Fff").Single().Kind); 111Assert.Equal(SymbolKind.Method, csFields.GetMembers("FfF").Single().Kind);

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

72Assert.Equal(SymbolKind.TypeParameter, varC1_T.Kind);

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

604var indexer = (PropertySymbol)@class.GetMembers().Where(m => m.Kind == SymbolKind.Property).Single(); 1035Assert.Equal(SymbolKind.Property, property.Kind); 1176var classIndexer = (PropertySymbol)@class.GetMembers().Single(s => s.Kind == SymbolKind.Property);

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

68Assert.Equal(SymbolKind.Parameter, localM1_1.Kind); 95Assert.Equal(SymbolKind.NamedType, varC108.Kind); 100Assert.Equal(SymbolKind.NamedType, sameName1.Kind); 102Assert.Equal(SymbolKind.Method, sameName2.Kind);

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

168var outerInterfaceProperty = outerInterface.GetMembers().Single(m => m.Kind == SymbolKind.Property); 178var innerInterfaceProperty = innerInterface.GetMembers().Single(m => m.Kind == SymbolKind.Property);

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

Symbols\Metadata\PE\NoPia.cs (63)

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

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

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

Symbols\Metadata\PE\TypeAccessibility.cs (6)

31where n.Kind == SymbolKind.Namespace && n.Name.Equals("System") 71where t.Kind == SymbolKind.Namespace && t.Name.Equals("Runtime") 75where t.Kind == SymbolKind.Namespace && t.Name.Equals("Remoting") 79where t.Kind == SymbolKind.Namespace && t.Name.Equals("Messaging") 93where t.Kind == SymbolKind.Namespace && t.Name.Equals("Security") 97where t.Kind == SymbolKind.Namespace && t.Name.Equals("AccessControl")

Symbols\MissingSpecialMember.cs (3)

537Assert.Equal(SymbolKind.ErrorType, symbol.Kind); // Not available 541Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind); 692Assert.True(symbol.Kind != SymbolKind.ErrorType, $"{wkt} should not be an error type");

Symbols\MockSymbolTests.cs (3)

32Assert.Equal(SymbolKind.ArrayType, ats1.Kind); 40Assert.Equal(SymbolKind.ArrayType, ats2.Kind); 57Assert.Equal(SymbolKind.PointerType, pts1.Kind);

Symbols\Retargeting\NoPia.cs (73)

Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (5)

85case SymbolKind.Method: 92case SymbolKind.Property: 95case SymbolKind.Event: 98case SymbolKind.ErrorType: 311return type.GetMembers().Where(s => s.Kind == SymbolKind.Property).Cast<PropertySymbol>().Single(p => p.Parameters.Length == parameterCount);

Symbols\Retargeting\RetargetingTests.cs (12)

1173case SymbolKind.Field: 1176case SymbolKind.NamedType: 1179case SymbolKind.Method: 1182case SymbolKind.Parameter: 1185case SymbolKind.Property: 1188case SymbolKind.TypeParameter: 1300case SymbolKind.NamedType: 1305case SymbolKind.Field: 1307case SymbolKind.Method: 1309case SymbolKind.Parameter: 1311case SymbolKind.Property: 1313case SymbolKind.TypeParameter:

Symbols\Source\BaseClassTests.cs (11)

Symbols\Source\CustomModifierCopyTests.cs (4)

698var classIndexer = (PropertySymbol)@class.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single(); 731var classIndexer = (PropertySymbol)@class.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single(); 772var classIndexer = (PropertySymbol)@class.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single(); 2126if (s.Kind != SymbolKind.Property)

Symbols\Source\DeclaringSyntaxNodeTests.cs (28)

Symbols\Source\DelegateTests.cs (2)

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

Symbols\Source\EventTests.cs (6)

83Assert.Equal(SymbolKind.Event, @event.Kind); 101Assert.Equal(SymbolKind.Field, associatedField.Kind); 122Assert.Equal(SymbolKind.Event, @event.Kind); 139Assert.Equal(SymbolKind.Field, associatedField.Kind); 160Assert.Equal(SymbolKind.Event, @event.Kind); 195Assert.Equal(SymbolKind.Event, @event.Kind);

Symbols\Source\ExternAliasTests.cs (1)

365Assert.Equal(SymbolKind.Alias, alias1.Kind);

Symbols\Source\FieldTests.cs (1)

68Assert.Equal(SymbolKind.Field, sym.Kind);

Symbols\Source\MethodTests.cs (7)

42Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 44Assert.Equal(SymbolKind.Parameter, x.Kind); 124Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 126Assert.Equal(SymbolKind.Parameter, x.Kind); 148Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 150Assert.Equal(SymbolKind.Parameter, x.Kind); 449Assert.Equal(SymbolKind.Method, method.Kind);

Symbols\Source\PropertyTests.cs (2)

402if (m.Kind == SymbolKind.Field) 421if (m.Kind == SymbolKind.Field)

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\Source\UsingAliasTests.cs (12)

Symbols\StaticAbstractMembersInInterfacesTests.cs (1)

23239if (m01.Kind == SymbolKind.Field)

Symbols\SymbolErrorTests.cs (3)

16958Assert.Equal(SymbolKind.ErrorType, fieldType.Type.Kind); 16985Assert.Equal(SymbolKind.ErrorType, fieldType.Kind); 17022Assert.Equal(SymbolKind.ErrorType, fieldType.Kind);

Symbols\TypeTests.cs (24)

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (1)

Syntax\FieldAndValueKeywordTests.cs (1)

1573var actualFields = comp.GetMember<NamedTypeSymbol>("Derived").GetMembers().Where(m => m.Kind == SymbolKind.Field).ToTestDisplayStrings();

Microsoft.CodeAnalysis.CSharp.Test.Utilities (28)

CompilationTestUtils.cs (1)

222get { return this.MemberGroup.WhereAsArray(s => s.Kind == SymbolKind.Method).SelectAsArray(s => (IMethodSymbol)s); }

CSharpTrackingDiagnosticAnalyzer.cs (1)

22protected override bool IsOnCodeBlockSupported(SymbolKind symbolKind, MethodKind methodKind, bool returnsVoid)

EmitMetadataTestBase.cs (7)

74var fields = t.GetMembers().Where(m => m.Kind == SymbolKind.Field).OrderBy(f => f.Name).Cast<FieldSymbol>(); 112SymbolKind actualParentKind; 135private static void GetAttributeParentNameAndKind(MetadataReader metadataReader, EntityHandle token, out string name, out SymbolKind kind) 141kind = SymbolKind.Assembly; 146kind = SymbolKind.NamedType; 151kind = SymbolKind.Method; 162public SymbolKind ParentKind;

Extensions.cs (15)

444if (typeSym.Kind == SymbolKind.NamedType && 723return type.Kind == SymbolKind.ErrorType; 755case SymbolKind.Method: 757case SymbolKind.Property: 759case SymbolKind.Event: 814case SymbolKind.Field: 816case SymbolKind.Method: 818case SymbolKind.Property: 820case SymbolKind.Event: 822case SymbolKind.Local: 824case SymbolKind.Parameter: 826case SymbolKind.ErrorType: 848case SymbolKind.NamedType: 851case SymbolKind.Method: 863if (sym.Kind == SymbolKind.Namespace)

FunctionPointerUtilities.cs (1)

28Assert.Equal(SymbolKind.FunctionPointerType, symbol.Kind);

NullableAttributesVisitor.cs (2)

103case SymbolKind.Parameter: 104case SymbolKind.TypeParameter:

TestAttributesVisitor.cs (1)

100return containingSymbol?.Kind == SymbolKind.Namespace ? null : containingSymbol;

Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests (6)

Metadata\WinMdDumpTest.cs (6)

58case SymbolKind.NamedType: 87case SymbolKind.Namespace: 95case SymbolKind.Method: 107case SymbolKind.Field: 123case SymbolKind.Property: 165case SymbolKind.Event:

Microsoft.CodeAnalysis.CSharp.Workspaces (68)

Classification\SyntaxClassification\DiscardSyntaxClassifier.cs (1)

49if (symbolInfo.Symbol?.Kind == SymbolKind.Discard)

Classification\SyntaxClassification\UsingDirectiveSyntaxClassifier.cs (1)

55else if (symbolInfo.Symbol?.Kind == SymbolKind.Namespace)

Recommendations\CSharpRecommendationServiceRunner.cs (10)

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

Rename\CSharpRenameRewriterLanguageService.cs (17)

542if (symbol != null && _renamedSymbol.Kind != SymbolKind.Local && _renamedSymbol.Kind != SymbolKind.RangeVariable && 760.Where(s => s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter) && s.Name == token.ValueText); 769(matchingLocal.IsKind(SymbolKind.Local) && ((ILocalSymbol)matchingLocal).Type.IsDelegateType()) || 770(matchingLocal.IsKind(SymbolKind.Parameter) && ((IParameterSymbol)matchingLocal).Type.IsDelegateType()); 807if (renamedSymbol.Kind is SymbolKind.Parameter or 808SymbolKind.Local or 809SymbolKind.RangeVariable) 833else if (renamedSymbol.Kind == SymbolKind.Label) 842else if (renamedSymbol.Kind == SymbolKind.Method) 860else if (renamedSymbol.Kind == SymbolKind.Alias) 892else if (renamedSymbol.Kind == SymbolKind.TypeParameter) 953var implicitReferencesMightConflict = renameSymbol.Kind == SymbolKind.Property && 958(renameSymbol.Kind == SymbolKind.Method && 1023if (symbol.Kind == SymbolKind.Method) 1074if (symbol.Kind == SymbolKind.Property)

Simplification\CSharpSimplificationService.Expander.cs (5)

646if (symbol.Kind is SymbolKind.Namespace or SymbolKind.NamedType) 663if (symbol.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property)

Simplification\Reducers\CSharpExtensionMethodReducer.cs (1)

57if (targetSymbol.Symbol != null && targetSymbol.Symbol.Kind == SymbolKind.Method)

Simplification\Simplifiers\AbstractCSharpSimplifier.cs (2)

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

Simplification\Simplifiers\ExpressionSimplifier.cs (2)

376if (type?.Kind == SymbolKind.DynamicType) 420if (rightSymbol != null && (rightSymbol.IsStatic || rightSymbol.Kind == SymbolKind.NamedType))

Simplification\Simplifiers\NameSimplifier.cs (2)

85if (symbol.Kind == SymbolKind.Method && name.Kind() == SyntaxKind.GenericName) 272if (!name.IsVar && symbol.Kind == SymbolKind.NamedType && !name.IsLeftSideOfQualifiedName())

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

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

1224return typeInfo.Type?.Kind == SymbolKind.ArrayType; 1232if (symbol?.Kind == SymbolKind.Field)

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true) 281if (semanticModel.GetSymbolInfo(n, cancellationToken).Symbol.IsKind(SymbolKind.Local) == true)

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

84var members = GetMembers(namedType).WhereAsArray(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s));

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

56if (symbol != null && symbol.Kind != SymbolKind.Namespace && model.GetSymbolInfo(namespacePart).Symbol is INamespaceSymbol) 216if (symbol?.Kind == SymbolKind.NamedType)

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

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

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

114if (targetType.Kind == SymbolKind.DynamicType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpSemanticFactsService.cs (2)

49visibleSymbols = visibleSymbols.WhereAsArray(s => !s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter));

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

Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (2)

CodeGeneration\SymbolEditorTests.cs (2)

1036var property = typeC.GetMembers().First(m => m.Kind == SymbolKind.Property); 1046var iproperty = typeI.GetMembers().First(m => m.Kind == SymbolKind.Property);

Microsoft.CodeAnalysis.EditorFeatures (7)

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (1)

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

Peek\PeekHelpers.cs (6)

57case SymbolKind.Event: 58case SymbolKind.Field: 59case SymbolKind.Method: 60case SymbolKind.Property: 64case SymbolKind.NamedType: 65case SymbolKind.Namespace:

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

CodeFixes\CodeFixServiceTests.cs (1)

1182}, SymbolKind.NamedType);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

1040}, SymbolKind.NamedType);

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (5)

DkmUtilities.cs (4)

279else if (symbol.Kind == SymbolKind.Field && ((IFieldSymbolInternal)symbol).IsVolatile) 291private static DkmEvaluationResultCategory GetResultCategory(SymbolKind kind) 295case SymbolKind.Method: 297case SymbolKind.Property:

PDB\MethodDebugInfo.Native.cs (1)

654if (type.Kind == SymbolKind.ErrorType)

Microsoft.CodeAnalysis.Extensions.Package (112)

Symbols\INamedTypeSymbolExtensions.cs (6)

Symbols\ISymbolExtensions.cs (25)

Symbols\ITypeSymbolExtensions.cs (2)

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

Symbols\SignatureComparer.cs (6)

Symbols\SymbolEquivalenceComparer.cs (5)

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (28)

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (17)

Microsoft.CodeAnalysis.Features (267)

AddImport\SymbolReferenceFinder.cs (2)

309if (symbol?.Kind is SymbolKind.Property or SymbolKind.Field)

ChangeSignature\AbstractChangeSignatureService.cs (8)

144if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property)) 276if (symbol.Definition.Kind == SymbolKind.NamedType) 292if (symbol.Definition.Kind == SymbolKind.Field) 945.Where(s => s.IsKind(SymbolKind.Local) || s.IsKind(SymbolKind.Parameter)) 950.Where(s => s.IsKind(SymbolKind.Property) || s.IsKind(SymbolKind.Field));

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (8)

227if (suppressionTargetInfo.TargetMemberNode != null && suppressionTargetInfo.TargetSymbol.Kind != SymbolKind.Namespace) 355protected static string? GetScopeString(SymbolKind targetSymbolKind) 359case SymbolKind.Event: 360case SymbolKind.Field: 361case SymbolKind.Method: 362case SymbolKind.Property: 365case SymbolKind.NamedType: 368case SymbolKind.Namespace:

CodeLens\CodeLensFindReferenceProgress.cs (1)

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

CodeLens\CodeLensReferencesService.cs (1)

353if (current.Kind != SymbolKind.Method)

Completion\CommonCompletionUtilities.cs (3)

104case SymbolKind.Method: 105case SymbolKind.Property: 106case SymbolKind.NamedType:

Completion\Providers\AbstractContextVariableArgumentProvider.cs (4)

41if (symbol.IsKind(SymbolKind.Parameter, out IParameterSymbol? parameter)) 43else if (symbol.IsKind(SymbolKind.Local, out ILocalSymbol? local)) 61if (symbol.IsKind(SymbolKind.Field, out IFieldSymbol? field)) 63else if (symbol.IsKind(SymbolKind.Property, out IPropertySymbol? property))

Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (2)

97fieldOrProperty.MatchesKind(SymbolKind.Field, SymbolKind.Property) &&

Completion\Providers\AbstractOverrideCompletionProvider.cs (3)

74SymbolKind.Event => ((IEventSymbol)symbol).Type, 75SymbolKind.Method => ((IMethodSymbol)symbol).ReturnType, 76SymbolKind.Property => ((IPropertySymbol)symbol).Type,

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (8)

181if (symbol.MatchesKind(SymbolKind.Local, SymbolKind.Parameter, SymbolKind.RangeVariable)) 186if (symbol.MatchesKind(SymbolKind.Field, SymbolKind.Property)) 191if (symbol.MatchesKind(SymbolKind.Event, SymbolKind.Method)) 257static bool SymbolMatches(SymbolAndSelectionInfo info, string? name, SymbolKind? kind, bool isGeneric)

Completion\Providers\AbstractSymbolCompletionProvider.cs (1)

388using var _ = PooledHashSet<(string Name, SymbolKind Kind)>.GetInstance(out var symbolNameAndKindSet);

Completion\Providers\SymbolCompletionItem.cs (2)

382internal static SymbolKind? GetKind(CompletionItem item) 383=> item.TryGetProperty("SymbolKind", out var kind) ? (SymbolKind?)int.Parse(kind) : null;

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

295var parameterNamingRule = await document.GetApplicableNamingRuleAsync(SymbolKind.Parameter, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false);

Debugging\AbstractBreakpointResolver.cs (7)

232SymbolKind.Method => ((IMethodSymbol)symbol).PartialImplementationPart, 233SymbolKind.Property => ((IPropertySymbol)symbol).PartialImplementationPart, 234SymbolKind.Event => ((IEventSymbol)symbol).PartialImplementationPart, 244var kind = methodOrProperty.Kind; 245if (kind is not (SymbolKind.Method or SymbolKind.Property)) 272if (methodOrProperty.IsKind(SymbolKind.Method))

DocumentHighlighting\AbstractDocumentHighlightsService.cs (4)

141case SymbolKind.Method: 215if (symbol.Kind == SymbolKind.Alias && 279case SymbolKind.Namespace: 282case SymbolKind.NamedType:

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (38)

311SymbolKind.Event => GetDisplayName((IEventSymbol)symbol), 312SymbolKind.Field => GetDisplayName((IFieldSymbol)symbol), 313SymbolKind.Method => GetDisplayName((IMethodSymbol)symbol), 314SymbolKind.NamedType => GetDisplayName((INamedTypeSymbol)symbol), 315SymbolKind.Parameter => FeaturesResources.parameter, 316SymbolKind.Local => FeaturesResources.local_variable, 317SymbolKind.Property => GetDisplayName((IPropertySymbol)symbol), 318SymbolKind.TypeParameter => FeaturesResources.type_parameter, 2636case SymbolKind.Field: 2639case SymbolKind.Event: 2642case SymbolKind.Property: 2648case SymbolKind.Method: 2655case SymbolKind.NamedType when oldMember is INamedTypeSymbol { DelegateInvokeMethod: { } oldInvokeMethod }: 3704=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field or SymbolKind.Event; 4281rudeEdit = (oldSymbol.Kind == SymbolKind.Field || newSymbol.Kind == SymbolKind.Field) ? RudeEditKind.FieldKindUpdate : RudeEditKind.Update; 4656oldMember is not IMethodSymbol { AssociatedSymbol.Kind: SymbolKind.Property or SymbolKind.Event }) 4840var rudeEdit = oldSymbol.ContainingSymbol.Kind == SymbolKind.Method ? RudeEditKind.GenericMethodUpdate : RudeEditKind.GenericTypeUpdate; 5173if (newDiagnosticSymbol.Kind is not (SymbolKind.Parameter or SymbolKind.TypeParameter)) 5188if (oldSymbol.Kind is not (SymbolKind.Parameter or SymbolKind.TypeParameter)) 5332case SymbolKind.Field: 5340case SymbolKind.Property: 5349case SymbolKind.Event: 5358case SymbolKind.Parameter: 5372parameter.ContainingType.GetMembers($"<{parameter.Name}>P").Any(m => m.Kind == SymbolKind.Field); 5727member.Kind is SymbolKind.Field or SymbolKind.Property && 6567if (oldSymbol.Kind == SymbolKind.RangeVariable) 6587if (oldSymbol.Kind == SymbolKind.Parameter) 6683SymbolKind.Parameter => ((IParameterSymbol)localOrParameter).Type, 6684SymbolKind.Local => ((ILocalSymbol)localOrParameter).Type, 6690Debug.Assert(local.Kind is not SymbolKind.RangeVariable);

EditAndContinue\RudeEditReportingCondition.cs (3)

18Contract.ThrowIfFalse(member.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field);

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

199=> symbol.Kind == SymbolKind.NamedType; 203return symbol.Kind is SymbolKind.Event or 204SymbolKind.Field or 205SymbolKind.Method or 206SymbolKind.Property;

ExtractInterface\AbstractExtractInterfaceService.cs (1)

432if (m.Kind == SymbolKind.Event || m.IsOrdinaryMethod())

ExtractMethod\MethodExtractor.Analyzer.cs (1)

877foreach (var pair in symbolMap.Where(p => p.Key.Kind == SymbolKind.Field))

FindUsages\DefinitionItem.DefaultDefinitionItem.cs (1)

45if (symbol is { Kind: not SymbolKind.Namespace })

FindUsages\FindUsagesHelpers.cs (1)

70return definition.Kind == SymbolKind.Parameter

GenerateFromMembers\GenerateFromMembersHelpers.cs (1)

101var parameterNamingRule = rules.Where(rule => rule.SymbolSpecification.AppliesTo(SymbolKind.Parameter, Accessibility.NotApplicable)).First();

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

608var fieldNamingRule = await _semanticDocument.Document.GetApplicableNamingRuleAsync(SymbolKind.Field, Accessibility.Private, _cancellationToken).ConfigureAwait(false);

GenerateType\AbstractGenerateTypeService.State.cs (1)

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

GoToBase\FindBaseHelpers.cs (3)

25if (symbol.Kind is SymbolKind.Property or SymbolKind.Method or SymbolKind.Event)

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (3)

247var resource = fieldOrProperty.Kind == SymbolKind.Field 282if (rule.SymbolSpecification.AppliesTo(SymbolKind.Field, Accessibility.Private)) 318if (rule.SymbolSpecification.AppliesTo(SymbolKind.Property, Accessibility.Public))

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (3)

576if (declaredSymbol.IsKind(SymbolKind.Property) 577|| declaredSymbol.IsKind(SymbolKind.Method) 578|| declaredSymbol.IsKind(SymbolKind.Event))

LanguageServiceIndexFormat\SymbolMoniker.cs (7)

23if (symbol.Kind is SymbolKind.Local or 24SymbolKind.RangeVariable or 25SymbolKind.Label or 26SymbolKind.Alias) 38if (symbol.Kind != SymbolKind.Namespace && symbol.ContainingAssembly == null) 53if (symbol.Kind == SymbolKind.Namespace) 60if (symbol.Kind == SymbolKind.Parameter)

MetadataAsSource\AbstractMetadataAsSourceService.AbstractWrappedSymbol.cs (1)

61public SymbolKind Kind => _symbol.Kind;

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (10)

33where m.Kind is SymbolKind.Event or 34SymbolKind.Field or 35SymbolKind.Method or 36SymbolKind.NamedType or 37SymbolKind.Property 46SymbolKind.Field => new WrappedFieldSymbol((IFieldSymbol)m, docCommentFormattingService), 47SymbolKind.Event => new WrappedEventSymbol((IEventSymbol)m, canImplementImplicitly, docCommentFormattingService), 48SymbolKind.Method => new WrappedMethodSymbol((IMethodSymbol)m, canImplementImplicitly, docCommentFormattingService), 49SymbolKind.NamedType => new WrappedNamedTypeSymbol((INamedTypeSymbol)m, canImplementImplicitly, docCommentFormattingService), 50SymbolKind.Property => new WrappedPropertySymbol((IPropertySymbol)m, canImplementImplicitly, docCommentFormattingService),

MetadataAsSource\MetadataAsSourceFileService.cs (7)

85if (symbol.Kind == SymbolKind.Namespace) 299case SymbolKind.Event: 300case SymbolKind.Field: 301case SymbolKind.Method: 302case SymbolKind.NamedType: 303case SymbolKind.Property: 304case SymbolKind.Parameter:

MetadataAsSource\MetadataAsSourceHelpers.cs (1)

58topLevelNamedType.Kind != SymbolKind.NamedType)

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

84var allDestinations = selectedMembers.All(m => m.IsKind(SymbolKind.Field))

PullMemberUp\MemberAndDestinationValidator.cs (3)

48_ => member.IsKind(SymbolKind.Property) || member.IsKind(SymbolKind.Event) || member.IsKind(SymbolKind.Field),

PullMemberUp\MembersPuller.cs (1)

288if (memberResult.MakeMemberDeclarationAbstract && !memberResult.Member.IsKind(SymbolKind.Field))

QuickInfo\CommonSemanticQuickInfoProvider.cs (2)

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

Rename\SymbolicRenameInfo.cs (7)

167if (symbol.Kind == SymbolKind.Alias && symbol.IsExtern) 171if (symbol.Kind == SymbolKind.NamedType && 188symbol.Kind != SymbolKind.Local && 189!(symbol.Kind == SymbolKind.Parameter && 190symbol.ContainingSymbol.Kind == SymbolKind.Method && 201if (symbol.Kind == SymbolKind.Property && symbol.ContainingType.IsAnonymousType) 207if (symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).MethodKind == MethodKind.UserDefinedOperator)

Shared\Extensions\ISymbolExtensions_Sorting.cs (12)

Shared\Utilities\ExtractTypeHelpers.cs (5)

205case SymbolKind.Event: 208case SymbolKind.Method: 213case SymbolKind.Property: 217case SymbolKind.Field: 241type.Kind != SymbolKind.TypeParameter &&

Snippets\SnippetFunctionService.cs (1)

65var enumFields = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Field && m.IsStatic);

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

58context.RegisterSymbolAction(AnalyzeFieldSymbol, SymbolKind.Field); 81}, SymbolKind.NamedType);

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

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

src\Analyzers\Core\Analyzers\QualifyMemberAccess\AbstractQualifyMemberAccessDiagnosticAnalyzer.cs (1)

106var symbolKind = operation switch

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

781case SymbolKind.NamedType: 782case SymbolKind.Method: 783case SymbolKind.Field: 784case SymbolKind.Property: 785case SymbolKind.Event:

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

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

606(symbol.IsStatic && symbol.Kind == SymbolKind.Local) ||

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

112case SymbolKind.Namespace: 113case SymbolKind.NamedType: 114case SymbolKind.Field: 115case SymbolKind.Parameter: 116case SymbolKind.Local:

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

287if (symbolInfo.Symbol.Kind != SymbolKind.Method)

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

551if (parameterType.Kind == SymbolKind.TypeParameter)

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

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

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

71var parameterNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Parameter, Accessibility.NotApplicable, cancellationToken).ConfigureAwait(false);

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

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

194if (semanticInfo.GetAllSymbols().Any(static s => s.Kind is SymbolKind.Local or SymbolKind.Parameter) &&

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

src\Analyzers\Core\CodeFixes\GenerateVariable\AbstractGenerateVariableService.State.cs (6)

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

233SymbolKind.Field, Accessibility.Private, cancellationToken).ConfigureAwait(false);

src\Analyzers\Core\CodeFixes\Naming\FallbackNamingRules.cs (8)

src\Analyzers\Core\CodeFixes\Naming\NamingExtensions.cs (1)

17this Document document, SymbolKind symbolKind, Accessibility accessibility, CancellationToken cancellationToken)

src\Analyzers\Core\CodeFixes\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (1)

67if (symbol.Kind == SymbolKind.Field)

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

Microsoft.CodeAnalysis.LanguageServer (2)

Services\LspExtractClassOptionsService.cs (2)

31_ => member.Kind == SymbolKind.Property || member.Kind == SymbolKind.Event

Microsoft.CodeAnalysis.LanguageServer.Protocol (1)

Handler\References\FindUsagesLSPContext.cs (1)

256if (symbol == null || symbol.Locations.IsEmpty || symbol.Kind is SymbolKind.Namespace)

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (2)

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (2)

116([SymbolKind.Property], Capitalization.AllUpper, ReportDiagnostic.Error)); 162([MethodKind.Ordinary, SymbolKind.Field], Capitalization.PascalCase, ReportDiagnostic.Error));

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (297)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (265)

DeclarePublicApiAnalyzer.cs (5)

144SymbolKind.NamedType, 145SymbolKind.Event, 146SymbolKind.Field, 147SymbolKind.Method); 150SymbolKind.Property);

DeclarePublicApiAnalyzer.Impl.cs (2)

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

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Microsoft.CodeAnalysis.ResxSourceGenerator (258)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Microsoft.CodeAnalysis.Test.Utilities (81)

Compilation\CompilationDifference.cs (1)

175var actual = EmitResult.Baseline.SynthesizedMembers.Single(e => e.Key.ToString() == typeName).Value.Where(s => s.Kind == SymbolKind.Field).Select(s => (IFieldSymbol)s.GetISymbol()).Select(f => f.Name + ": " + f.Type);

Compilation\CompilationExtensions.cs (6)

239if (declaration.DeclaredSymbol.Kind == SymbolKind.Method && compilation.Language == LanguageNames.VisualBasic) 261case SymbolKind.Field: 262case SymbolKind.Event: 263case SymbolKind.Method: 264case SymbolKind.NamedType: 265case SymbolKind.Property:

Compilation\ControlFlowGraphVerifier.cs (1)

1686Assert.True(false, $"{(symbol.Kind == SymbolKind.Local ? "Local" : "Method")} without owning region {symbol.ToTestDisplayString()} in [{getBlockId(block)}]\n{finalGraph()}");

CompilationVerifier.cs (1)

877.Where(s => s.Kind == SymbolKind.Field)

Diagnostics\CommonDiagnosticAnalyzers.cs (32)

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (1)

97SymbolKind.Field

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (8)

72SymbolKind.Event, 73SymbolKind.Field, 74SymbolKind.Method, 75SymbolKind.NamedType, 76SymbolKind.Namespace, 77SymbolKind.Property); 102SymbolKind.NamedType); 286SymbolKind.NamedType);

Diagnostics\TestDiagnosticAnalyzer.cs (2)

17protected static readonly ImmutableArray<SymbolKind> AllSymbolKinds = GetAllEnumValues<SymbolKind>();

Diagnostics\TrackingDiagnosticAnalyzer.cs (29)

Microsoft.CodeAnalysis.UnitTests (3)

CorLibTypesTests.cs (2)

82Assert.Equal(SymbolKind.ErrorType, symbol.Kind); 86Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind);

Diagnostics\AnalysisContextInfoTests.cs (1)

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

Microsoft.CodeAnalysis.VisualBasic (1135)

Analysis\FlowAnalysis\AbstractFlowPass.vb (8)

Analysis\FlowAnalysis\AlwaysAssignedWalker.vb (1)

48If v.Exists AndAlso v.Symbol.Kind <> SymbolKind.Field Then

Analysis\FlowAnalysis\DataFlowPass.vb (21)

Analysis\FlowAnalysis\DataFlowsInWalker.vb (4)

35If var.Kind <> SymbolKind.Local OrElse Not DirectCast(var, LocalSymbol).IsStatic Then 113Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 116Debug.Assert(local.Kind <> SymbolKind.RangeVariable) 118If local.Kind = SymbolKind.Field Then

Analysis\FlowAnalysis\DataFlowsOutWalker.vb (8)

46If var.Kind <> SymbolKind.Local OrElse Not DirectCast(var, LocalSymbol).IsStatic Then 72If Not Me.State.IsAssigned(slot) AndAlso variable.Kind <> SymbolKind.RangeVariable AndAlso 73(variable.Kind <> SymbolKind.Local OrElse Not DirectCast(variable, LocalSymbol).IsStatic) Then 147Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 149If Not _dataFlowsOut.Contains(local) AndAlso local.Kind <> SymbolKind.RangeVariable AndAlso Not IsInside Then 150If local.Kind = SymbolKind.Field Then 177Dim isByRefParameter As Boolean = variable.Kind = SymbolKind.Parameter AndAlso DirectCast(variable, ParameterSymbol).IsByRef 178Dim isStaticLocal As Boolean = variable.Kind = SymbolKind.Local AndAlso DirectCast(variable, LocalSymbol).IsStatic

Analysis\FlowAnalysis\DefinitelyAssignedWalker.vb (1)

76symbol.Kind <> SymbolKind.Field Then

Analysis\FlowAnalysis\ReadWriteWalker.vb (4)

102ElseIf variable.Kind <> SymbolKind.RangeVariable Then 159Case SymbolKind.Local 164Case SymbolKind.Parameter 169Case SymbolKind.RangeVariable

Analysis\FlowAnalysis\UnassignedVariablesWalker.vb (2)

42Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 44If local.Kind = SymbolKind.Field Then

Analysis\InitializerRewriter.vb (1)

88If member.Kind = SymbolKind.Method Then

Analysis\IteratorAndAsyncAnalysis\IteratorAndAsyncCaptureWalker.vb (10)

Binding\Binder.vb (4)

400Case SymbolKind.Method 403Case SymbolKind.NamedType 517If Not candidate.IsShared OrElse candidate.Kind <> SymbolKind.Property Then 955symbol.Kind <> SymbolKind.Property AndAlso

Binding\Binder_Attributes.vb (8)

178If symbol.Kind = SymbolKind.Namespace Then 181ElseIf symbol.Kind = SymbolKind.TypeParameter Then 184ElseIf symbol.Kind <> SymbolKind.NamedType Then 246If errorType.CandidateSymbols.Length = 1 AndAlso errorType.CandidateSymbols(0).Kind = SymbolKind.NamedType Then 460Case SymbolKind.Field 466Case SymbolKind.Property 616Case SymbolKind.Field 619Case SymbolKind.Property

Binding\Binder_Constraints.vb (4)

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_Delegates.vb (1)

943If sym.Kind = SymbolKind.Event Then

Binding\Binder_Expressions.vb (53)

Binding\Binder_Imports.vb (5)

86If aliasTarget.Kind <> SymbolKind.Namespace Then 118If aliasTarget.Kind <> SymbolKind.ErrorType Then 168If importedSymbol.Kind <> SymbolKind.Namespace Then 181If importedSymbol.Kind <> SymbolKind.ErrorType Then 191If importedSymbol.Kind = SymbolKind.NamedType Then

Binding\Binder_Initializers.vb (3)

142Debug.Assert(firstFieldOrProperty.Kind = SymbolKind.Field) 149ElseIf firstFieldOrProperty.Kind = SymbolKind.Field Then 233Debug.Assert(fieldSymbol.Type.Kind = SymbolKind.ArrayType)

Binding\Binder_Invocation.vb (16)

58If Me.ContainingMember.Kind = SymbolKind.Method AndAlso DirectCast(Me.ContainingMember, MethodSymbol).MethodKind = MethodKind.Constructor Then 288ElseIf targetType.Kind = SymbolKind.NamedType AndAlso targetType.TypeKind = TypeKind.Delegate Then 552Dim kind As SymbolKind = result.Symbols(0).Kind 554If kind = SymbolKind.Method OrElse kind = SymbolKind.Property Then 896If methodOrProperty.Kind = SymbolKind.Method Then 1730If underlyingSymbol.Kind = SymbolKind.Method Then 2272Debug.Assert(candidate.UnderlyingSymbol.Kind = SymbolKind.Method) 2290Dim candidateIsAProperty As Boolean = (candidateSymbol.Kind = SymbolKind.Property) 2302If targetType.Kind <> SymbolKind.ArrayType Then 2304If targetType.Kind <> SymbolKind.ErrorType Then 2691Dim candidateIsAProperty As Boolean = (candidate.Candidate.UnderlyingSymbol.Kind = SymbolKind.Property) 3127Case SymbolKind.Field, SymbolKind.Property, SymbolKind.Event 3130Case SymbolKind.Method

Binding\Binder_Lookup.vb (22)

130If options = LookupOptions.LabelsOnly AndAlso sym.Kind = SymbolKind.Label Then 149If sym.Kind = SymbolKind.Local AndAlso DirectCast(sym, LocalSymbol).IsFunctionValue Then 167If unwrappedSym.Kind = SymbolKind.NamedType AndAlso unwrappedSym.EmbeddedSymbolKind = EmbeddedSymbolKind.EmbeddedAttribute AndAlso 181Case SymbolKind.NamedType, SymbolKind.ErrorType 187Case SymbolKind.TypeParameter, SymbolKind.Namespace 192Case SymbolKind.Alias 201Case SymbolKind.Method 244ElseIf sym.Kind = SymbolKind.Method Then 252If unwrappedSym.Kind = SymbolKind.Method AndAlso unwrappedSym.ContainingSymbol IsNot Nothing Then 289sym.Kind <> SymbolKind.Method Then 436If sym.Kind = SymbolKind.Namespace Then 760If sym.Kind <> SymbolKind.Field Then 804If sym.Kind <> SymbolKind.Field Then 868Dim lookingForOverloadsOfKind As SymbolKind? = Nothing 1155result.Symbols(0).Kind <> SymbolKind.Method) Then 1533FilterSymbolsInLookupResult(currentResult, SymbolKind.Event, leaveInsteadOfRemoving:=leaveEventsOnly.Value) 1546FilterSymbolsInLookupResult(lookupResult, SymbolKind.Method, leaveInsteadOfRemoving:=True) 1584Private Shared Sub FilterSymbolsInLookupResult(result As LookupResult, kind As SymbolKind, leaveInsteadOfRemoving As Boolean) 1685lookupResult.Symbols(0).Kind <> SymbolKind.Method Then 1758If leaveEventsOnly.HasValue AndAlso (newSymbol.Kind = SymbolKind.Event) <> leaveEventsOnly.Value Then

Binding\Binder_ObjectInitializer.vb (2)

28extendedErrorType.CandidateSymbols(0).Kind = SymbolKind.NamedType Then 898Return y.Kind = SymbolKind.Method

Binding\Binder_Query.vb (1)

730Dim result As Boolean = (lookup.IsGood AndAlso lookup.Symbols(0).Kind = SymbolKind.RangeVariable)

Binding\Binder_Statements.vb (28)

Binding\Binder_Symbols.vb (8)

231If symbol IsNot Nothing AndAlso symbol.Kind = SymbolKind.Alias Then 278If sym.Kind = SymbolKind.Alias Then 304If diagBag.AccumulatesDiagnostics AndAlso typeSymbol.Kind = SymbolKind.NamedType AndAlso binder.SourceModule.AnyReferencedAssembliesAreLinked Then 567lookupResult.SingleSymbol.Kind = SymbolKind.Alias 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\Binder_Utils.vb (1)

862Debug.Assert(Not (container.Kind = SymbolKind.Method AndAlso DirectCast(container, MethodSymbol).MethodKind = MethodKind.DelegateInvoke))

Binding\Binder_XmlLiterals.vb (2)

985Case SymbolKind.Method 992Case SymbolKind.Property

Binding\BinderBuilder.vb (10)

202nsSymbol = DirectCast(binder.NamespaceSymbol.GetMembers(nsSymbol.Name).First(Function(s) s.Kind = SymbolKind.Namespace), NamespaceSymbol) 232If containingSymbol.Kind = SymbolKind.Namespace Then 242While containingSymbol.Kind <> SymbolKind.Namespace 248Debug.Assert(containingSymbol IsNot Nothing AndAlso containingSymbol.Kind = SymbolKind.Namespace) 276Case SymbolKind.Parameter 424Debug.Assert((fieldOrProperty.Kind = SymbolKind.Field) OrElse (fieldOrProperty.Kind = SymbolKind.Property)) 425Debug.Assert(additionalFieldsOrProperties.All(Function(s) s.Kind = SymbolKind.Field OrElse s.Kind = SymbolKind.Property)) 430If fieldOrProperty.Kind = SymbolKind.Field Then

Binding\BinderFactory.vb (4)

325fieldOrProperty = containingNamedTypeBinder.ContainingType.FindMember(identifier.ValueText, SymbolKind.Field, identifier.Span, _tree) 337fieldOrProperty = containingNamedTypeBinder.ContainingType.FindMember(identifier.ValueText, SymbolKind.Property, identifier.Span, _tree) 357Dim field = containingType.FindMember(identifier.ValueText, SymbolKind.Field, identifier.Span, _tree) 647(symbol.Kind = SymbolKind.Method) Then

Binding\DeclarationInitializerBinder.vb (6)

40Debug.Assert((symbol.Kind = SymbolKind.Field) OrElse (symbol.Kind = SymbolKind.Property) OrElse (symbol.Kind = SymbolKind.Parameter)) 41Debug.Assert(additionalSymbols.All(Function(s) s.Kind = symbol.Kind AndAlso (s.Kind = SymbolKind.Field OrElse s.Kind = SymbolKind.Property))) 42Debug.Assert(symbol.Kind <> SymbolKind.Parameter OrElse additionalSymbols.IsEmpty)

Binding\DocumentationCommentBinder.vb (5)

51Debug.Assert(binderContainingMember.Kind = SymbolKind.Namespace) 186Case SymbolKind.Method, SymbolKind.Property 206Case SymbolKind.Method 223Case SymbolKind.Property

Binding\DocumentationCommentCrefBinder.vb (20)

Binding\DocumentationCommentCrefBinder_Compat.vb (11)

176Case SymbolKind.Namespace 179Case SymbolKind.Alias 185Case SymbolKind.NamedType, SymbolKind.ArrayType 188Case SymbolKind.Property 199Case SymbolKind.Field 210Case SymbolKind.Method 395Case SymbolKind.Method 400Case SymbolKind.NamedType, SymbolKind.ErrorType 405Case SymbolKind.Alias

Binding\DocumentationCommentParamBinder.vb (4)

28Case SymbolKind.NamedType 37Case SymbolKind.Method 40Case SymbolKind.Property 43Case SymbolKind.Event

Binding\DocumentationCommentTypeParamBinder.vb (2)

41Case SymbolKind.NamedType 44Case SymbolKind.Method

Binding\DocumentationCommentTypeParamRefBinder.vb (1)

47If symbol.Kind = SymbolKind.TypeParameter Then

Binding\ForOrForEachBlockBinder.vb (2)

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

Binding\ImportedTypesAndNamespacesMembersBinder.vb (6)

71currentResult.SingleSymbol.Kind = SymbolKind.Namespace AndAlso 78Dim lookupResultIsNamespace As Boolean = (lookupResult.Symbols(0).Kind = SymbolKind.Namespace) 79Dim currentResultIsNamespace As Boolean = (currentResult.Symbols(0).Kind = SymbolKind.Namespace) 119If lookupResult.IsGood AndAlso lookupResult.Symbols.Count > 1 AndAlso lookupResult.Symbols(0).Kind = SymbolKind.Namespace Then 136If importedSym.NamespaceOrType.Kind = SymbolKind.NamedType Then 150If importedSym.NamespaceOrType.Kind = SymbolKind.NamedType Then

Binding\InitializerSemanticModel.vb (4)

45If Me.MemberSymbol.Kind = SymbolKind.Field Then 102Case SymbolKind.Field 132Case SymbolKind.Property 145Case SymbolKind.Parameter

Binding\LookupResult.vb (16)

Binding\SyntheticBoundTrees\SynthesizedPropertyAccessorBase.vb (1)

145If member.Kind = SymbolKind.Method Then

BoundTree\BoundArrayCreation.vb (1)

25If Type.Kind = SymbolKind.ArrayType Then

BoundTree\BoundAssignmentOperator.vb (1)

95DirectCast(Left, BoundFieldAccess).FieldSymbol.AssociatedSymbol.Kind = SymbolKind.Property AndAlso

BoundTree\BoundExpressionExtensions.vb (1)

620If symbol.Kind = SymbolKind.Namespace AndAlso DirectCast(symbol, NamespaceSymbol).NamespaceKind = NamespaceKindNamespaceGroup Then

Compilation\ClsComplianceChecker.vb (46)

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

431needDiagnostic = bindResult(0).Kind <> SymbolKind.TypeParameter 717Case SymbolKind.Field 723Case SymbolKind.Method 729Case SymbolKind.Property 732Case SymbolKind.Event 735Case SymbolKind.NamedType 766Case SymbolKind.NamedType 779Case SymbolKind.Field, 780SymbolKind.Event, 781SymbolKind.Property, 782SymbolKind.Method

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

98Case SymbolKind.Field 101Case SymbolKind.Event 106Case SymbolKind.Method 119Case SymbolKind.NamedType 135Case SymbolKind.Property 654If symbol.Kind = SymbolKind.TypeParameter Then

Compilation\DocumentationComments\DocumentationCommentCompiler.vb (5)

117Debug.Assert(symbol.Kind = SymbolKind.Event OrElse 118symbol.Kind = SymbolKind.Field OrElse 119symbol.Kind = SymbolKind.Method OrElse 120symbol.Kind = SymbolKind.NamedType OrElse 121symbol.Kind = SymbolKind.Property)

Compilation\DocumentationComments\DocumentationCommentWalker.vb (1)

189If symbol.Kind = SymbolKind.TypeParameter Then

Compilation\MethodCompiler.vb (8)

136If symbol.Kind = SymbolKind.Method AndAlso symbol.IsImplicitlyDeclared AndAlso 394If symbol.Kind = SymbolKind.NamedType Then 401If symbol.Kind = SymbolKind.Method Then 473Debug.Assert(fieldOrProperty.Kind = SymbolKind.Field) 660Case SymbolKind.NamedType 663Case SymbolKind.Method 764If member.IsShared OrElse Not member.IsFromCompilation(_compilation) OrElse member.Kind <> SymbolKind.Method Then 868If member.Kind = SymbolKind.Method Then

Compilation\NamespaceScopeBuilder.vb (2)

38ElseIf target.Kind <> SymbolKind.ErrorType AndAlso Not target.ContainingAssembly.IsLinked Then 53Debug.Assert(target.Kind <> SymbolKind.ErrorType)

Compilation\SemanticModel.vb (24)

Compilation\SyntaxTreeSemanticModel.vb (12)

526Case SymbolKind.ArrayType, 527SymbolKind.TypeParameter, 528SymbolKind.NamedType 617If symbol.Kind = SymbolKind.TypeParameter Then 646If resultSymbol.Kind = SymbolKind.Namespace AndAlso 716Case SymbolKind.Method 726Case SymbolKind.Property 736Case SymbolKind.Event 1063Case SymbolKind.Method 1065Case SymbolKind.Event 1075Case SymbolKind.Property 1077Case SymbolKind.NamedType

Compilation\SynthesizedMetadataCompiler.vb (1)

52Case SymbolKind.NamedType

Compilation\VisualBasicCompilation.vb (2)

1568If (Not lookupResult.IsGoodOrAmbiguous) OrElse lookupResult.Symbols(0).Kind <> SymbolKind.Method Then 2023Return If(within0.Kind = SymbolKind.Assembly,

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.vb (2)

110If containingSymbol.Kind = SymbolKind.NamedType Then 120ElseIf containingSymbol.Kind = SymbolKind.Method Then

Emit\EditAndContinue\EmitHelpers.vb (1)

156If type.Kind = SymbolKind.ErrorType Then

Emit\EditAndContinue\PEDeltaAssemblyBuilder.vb (2)

187If member.Kind <> SymbolKind.Property Then 213Debug.Assert(members.Length = 1 AndAlso members(0).Kind = SymbolKind.Method)

Emit\EditAndContinue\VisualBasicDefinitionMap.vb (1)

112If member.Kind = SymbolKind.Field Then

Emit\EditAndContinue\VisualBasicSymbolMatcher.vb (12)

243Case SymbolKind.NetModule 246Case SymbolKind.Namespace 305Case SymbolKind.Namespace 320Case SymbolKind.NamedType 348Case SymbolKind.NamedType, 349SymbolKind.ErrorType 352Case SymbolKind.Method 506Case SymbolKind.ArrayType 509Case SymbolKind.NamedType, 510SymbolKind.ErrorType 513Case SymbolKind.TypeParameter 524If symbol.Kind = SymbolKind.NamedType Then

Emit\NamedTypeSymbolAdapter.vb (5)

289If member.Kind = SymbolKind.Method Then 483If member.Kind = SymbolKind.Method Then 915If member.Kind = SymbolKind.Event Then 987If member.Kind = SymbolKind.Method Then 1004If member.Kind = SymbolKind.Property Then

Emit\NoPia\EmbeddedEvent.vb (1)

113If m.Kind = SymbolKind.Method Then

Emit\NoPia\EmbeddedType.vb (4)

235Case SymbolKind.Field 237Case SymbolKind.Method 239Case SymbolKind.Property 241Case SymbolKind.Event

Emit\NoPia\EmbeddedTypesManager.vb (3)

223If member.Kind <> SymbolKind.NamedType Then 430Case SymbolKind.Property 432Case SymbolKind.Event

Emit\PEAssemblyBuilder.vb (1)

157Dim subnamespace = DirectCast(result.GetMembers(partName).FirstOrDefault(Function(m) m.Kind = SymbolKind.Namespace), NamespaceSymbol)

Emit\PEModuleBuilder.vb (16)

209Case SymbolKind.Namespace 217Case SymbolKind.Namespace, SymbolKind.NamedType 225Case SymbolKind.NamedType 233Case SymbolKind.NamedType 236Case SymbolKind.Method 245Case SymbolKind.Property, 246SymbolKind.Field 249Case SymbolKind.Event 360If sym.Kind = SymbolKind.NamedType Then 369Debug.Assert(sym.Kind = SymbolKind.Namespace) 500If symbol.Kind = SymbolKind.NamedType Then 656Case SymbolKind.Namespace 664Case SymbolKind.Namespace, SymbolKind.NamedType 672Case SymbolKind.NamedType

Emit\SymbolAdapter.vb (2)

81Debug.Assert(Me.Kind <> SymbolKind.Assembly) 121If Me.Kind = SymbolKind.Assembly Then

Emit\SymbolTranslator.vb (7)

132If namedTypeSymbol.OriginalDefinition.Kind = SymbolKind.ErrorType Then 136If diagInfo Is Nothing AndAlso namedTypeSymbol.Kind = SymbolKind.ErrorType Then 253Case SymbolKind.ArrayType 255Case SymbolKind.NamedType, SymbolKind.ErrorType 257Case SymbolKind.TypeParameter 460Return container.Kind = SymbolKind.Method AndAlso (DirectCast(container, MethodSymbol)).IsGenericMethod OrElse

Emit\TypeParameterSymbolAdapter.vb (9)

63If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.Method Then 74If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.Method Then 92If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 104If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 144Dim kind As SymbolKind = AdaptedTypeParameterSymbol.ContainingSymbol.Kind 147If kind = SymbolKind.NamedType Then 150If kind = SymbolKind.Method Then 157If kind = SymbolKind.NamedType Then 160If kind = SymbolKind.Method Then

Errors\MessageProvider.vb (2)

98If symbol.Kind = SymbolKind.Assembly OrElse symbol.Kind = SymbolKind.Namespace Then

Lowering\AsyncRewriter\AsyncRewriter.AsyncMethodToClassRewriter.Spilling.vb (2)

529Case SymbolKind.Event 535Case SymbolKind.Field

Lowering\AsyncRewriter\AsyncRewriter.vb (3)

382If returnType.Kind = SymbolKind.NamedType AndAlso 554If result.Symbols(0).Kind = SymbolKind.Method Then 613If result.Symbols(0).Kind = SymbolKind.Property Then

Lowering\ExpressionLambdaRewriter\ExpressionLambdaRewriter.vb (4)

617Debug.Assert(leftSymbol.Kind = SymbolKind.Field OrElse leftSymbol.Kind = SymbolKind.Property) 619Dim memberRef As BoundExpression = If(leftSymbol.Kind = SymbolKind.Field, 626If(leftSymbol.Kind = SymbolKind.Field,

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (3)

146If nonLambda?.Kind = SymbolKind.Method Then 155Case SymbolKind.Property 160Case SymbolKind.Event

Lowering\LambdaRewriter\LambdaRewriter.Analysis.vb (2)

255local.ContainingSymbol.Kind <> SymbolKind.Method, 408If variableOrParameter.Kind = SymbolKind.Local Then

Lowering\LambdaRewriter\LambdaRewriter.vb (5)

269Debug.Assert(captured.Kind <> SymbolKind.Local OrElse 563If _innermostFramePointer.Kind = SymbolKind.Parameter AndAlso _topLevelMethod.MethodKind = MethodKind.Constructor AndAlso 596If variable.Kind <> SymbolKind.Local Then 646Case SymbolKind.Parameter 658Case SymbolKind.Local

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.vb (2)

201(fromMember.Kind = SymbolKind.Field OrElse (fromMember.Kind = SymbolKind.Method AndAlso

Lowering\LocalRewriter\LocalRewriter_FieldOrPropertyInitializer.vb (2)

79If symbol.Kind = SymbolKind.Field Then 102If symbol.Kind = SymbolKind.Field Then

Lowering\LocalRewriter\LocalRewriter_With.vb (1)

175If member.Kind = SymbolKind.Field Then

Lowering\StateMachineRewriter\StateMachineRewriter.StateMachineMethodToClassRewriter.vb (2)

315Debug.Assert(localOrParameter.Kind = SymbolKind.Local OrElse localOrParameter.Kind = SymbolKind.Parameter)

Lowering\StateMachineRewriter\StateMachineRewriter.vb (4)

172Debug.Assert(variable.Kind = SymbolKind.Local OrElse variable.Kind = SymbolKind.Parameter) 175Case SymbolKind.Local 189Case SymbolKind.Parameter

Lowering\SynthesizedSubmissionFields.vb (1)

57If hostObjectTypeSymbol IsNot Nothing AndAlso hostObjectTypeSymbol.Kind <> SymbolKind.ErrorType Then

Lowering\WithExpressionRewriter.vb (1)

324If Not (state.DoNotUseByRefLocal OrElse (value.Kind = BoundKind.ArrayAccess AndAlso value.Type.Kind = SymbolKind.TypeParameter)) Then

Semantics\AccessCheck.vb (30)

Semantics\Conversions.vb (64)

Semantics\Operators.vb (8)

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 2918If member.Kind = SymbolKind.Method Then 2945If type.Kind = SymbolKind.TypeParameter Then

Semantics\OverloadResolution.vb (15)

3252If candidateSymbol.Kind = SymbolKind.Method Then 3278Dim candidateIsAProperty As Boolean = (candidate.Candidate.UnderlyingSymbol.Kind = SymbolKind.Property) 3293If targetType.Kind <> SymbolKind.ArrayType Then 3383If targetType.Kind = SymbolKind.ErrorType Then 3458If targetType.Kind = SymbolKind.ErrorType Then 4944If leftType.Kind = SymbolKind.NamedType AndAlso rightType.Kind = SymbolKind.NamedType Then 5080If symbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 5106Case SymbolKind.TypeParameter 5110Case SymbolKind.ArrayType 5115Case SymbolKind.NamedType, SymbolKind.ErrorType 5206paramType.Kind = SymbolKind.ArrayType Then 5221If paramForGenericityCheck.ContainingSymbol.Kind = SymbolKind.Method Then 5233paramType.Kind = SymbolKind.ArrayType Then

Semantics\TypeInference\TypeArgumentInference.vb (19)

928If targetType.Kind <> SymbolKind.ArrayType Then 970If targetType.Kind = SymbolKind.ErrorType Then 1068Case SymbolKind.TypeParameter 1088Case SymbolKind.ArrayType 1092Case SymbolKind.NamedType 1295Case SymbolKind.TypeParameter 1310Case SymbolKind.ArrayType 1314Case SymbolKind.NamedType 1424ElseIf parameterType.Kind = SymbolKind.NamedType Then 1431Dim argumentTypeAsNamedType = If(argumentType.Kind = SymbolKind.NamedType, DirectCast(argumentType.GetTupleUnderlyingTypeOrSelf(), NamedTypeSymbol), Nothing) 1771Dim fixedTypeAsNamedType = If(fixedType.Kind = SymbolKind.NamedType, DirectCast(fixedType, NamedTypeSymbol), Nothing) 1787Dim baseSearchTypeKind As SymbolKind = baseSearchType.Kind 1789If baseSearchTypeKind <> SymbolKind.NamedType AndAlso baseSearchTypeKind <> SymbolKind.TypeParameter AndAlso 1790Not (baseSearchTypeKind = SymbolKind.ArrayType AndAlso DirectCast(baseSearchType, ArrayTypeSymbol).IsSZArray) Then 1840Case SymbolKind.TypeParameter 1872Case SymbolKind.TypeParameter 2171lambdaReturnType IsNot Nothing AndAlso lambdaReturnType.Kind = SymbolKind.NamedType AndAlso 2172returnType IsNot Nothing AndAlso returnType.Kind = SymbolKind.NamedType Then

SymbolDisplay\SymbolDisplayVisitor.Members.vb (3)

331If associatedPropertyOrEvent.Kind = SymbolKind.Property Then 618Dim isConst = symbol.Kind = SymbolKind.Field AndAlso DirectCast(symbol, IFieldSymbol).IsConst 700symbol.Kind <> SymbolKind.Method OrElse

SymbolDisplay\SymbolDisplayVisitor.Types.vb (2)

30While underlyingNonArrayType.Kind = SymbolKind.ArrayType 502If typeArg.Kind = SymbolKind.TypeParameter Then

SymbolDisplay\SymbolDisplayVisitor.vb (2)

379containingSymbol.Kind = SymbolKind.Namespace AndAlso 394symbol.Kind = SymbolKind.Field AndAlso

Symbols\AliasSymbol.vb (3)

92''' <returns><see cref="SymbolKind.Alias"/></returns> 93Public Overrides ReadOnly Property Kind As SymbolKind 95Return SymbolKind.Alias

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType_TemplateSymbol.vb (1)

120If m.Kind = SymbolKind.Field Then

Symbols\ArrayTypeSymbol.vb (4)

243''' Returns <see cref="SymbolKind"/> of the symbol. 245''' <returns><see cref="SymbolKind.ArrayType"/></returns> 246Public Overrides ReadOnly Property Kind As SymbolKind 248Return SymbolKind.ArrayType

Symbols\AssemblySymbol.vb (3)

168Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 170Return SymbolKind.Assembly 717Return candidate IsNot Nothing AndAlso (candidate.Kind <> SymbolKind.ErrorType OrElse Not (TypeOf candidate Is MissingMetadataTypeSymbol))

Symbols\Attributes\AttributeData.vb (18)

Symbols\Attributes\SourceAttributeData.vb (2)

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

Symbols\BaseTypeAnalysis.vb (2)

55Debug.Assert(current.Head.Kind = SymbolKind.NamedType) 195If current Is Nothing OrElse current.Kind = SymbolKind.ErrorType Then

Symbols\ConstraintsHelper.vb (5)

438If type.Kind = SymbolKind.NamedType Then 770Case SymbolKind.ErrorType 773Case SymbolKind.TypeParameter 801Case SymbolKind.ErrorType 804Case SymbolKind.TypeParameter

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

215Case SymbolKind.Field 223Case SymbolKind.Method 248Case SymbolKind.Property 265Case SymbolKind.NamedType 277Case SymbolKind.Field 286Case SymbolKind.Method 307Debug.Assert(symbol.Kind = SymbolKind.NamedType OrElse 308symbol.Kind = SymbolKind.Property OrElse 309symbol.Kind = SymbolKind.Method OrElse 310symbol.Kind = SymbolKind.Field) 339Case SymbolKind.Field 342Case SymbolKind.Method 345Case SymbolKind.NamedType 348Case SymbolKind.Property

Symbols\ErrorTypeSymbol.vb (2)

104Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 106Return SymbolKind.ErrorType

Symbols\EventSymbol.vb (2)

131Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 133Return SymbolKind.[Event]

Symbols\ExtendedErrorTypeSymbol.vb (2)

57candidateSymbols(0).Kind = SymbolKind.Namespace AndAlso 66Debug.Assert(item.Kind <> SymbolKind.Namespace OrElse DirectCast(item, NamespaceSymbol).NamespaceKind <> NamespaceKindNamespaceGroup)

Symbols\FieldSymbol.vb (2)

177Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 179Return SymbolKind.Field

Symbols\LabelSymbol.vb (2)

90Public Overrides ReadOnly Property Kind As SymbolKind 92Return SymbolKind.Label

Symbols\MemberSignatureComparer.vb (9)

55Case SymbolKind.Method 57Case SymbolKind.Property 59Case SymbolKind.Event 72Case SymbolKind.Method 74Case SymbolKind.Property 76Case SymbolKind.Event 87Case SymbolKind.Method, SymbolKind.Property, SymbolKind.Event

Symbols\MergedNamespaceSymbol.vb (1)

216If (childSym.Kind = SymbolKind.Namespace) Then

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

195Case SymbolKind.TypeParameter 198Case SymbolKind.ArrayType 202Case SymbolKind.NamedType, SymbolKind.ErrorType 277Debug.Assert(newresult Is result OrElse (newresult.Kind = SymbolKind.ErrorType))

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

548If m.Kind <> SymbolKind.Method Then

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

384Return candidate.Kind <> SymbolKind.ErrorType OrElse Not (TypeOf candidate Is MissingMetadataTypeSymbol)

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

176While s.Kind <> SymbolKind.Namespace 392If (Not member.IsShared AndAlso member.Kind = SymbolKind.Field) Then 523Return GetMembers(Of FieldSymbol)(GetMembers(), SymbolKind.Field, offset:=0) 530Dim index = GetIndexOfFirstMember(members, SymbolKind.Method) 535If member.Kind <> SymbolKind.Method Then 551If index >= members.Length OrElse members(index).Kind <> SymbolKind.Method Then 572If index = members.Length OrElse members(index).Kind <> SymbolKind.Method Then 604Return GetMembers(Of PropertySymbol)(GetMembers(), SymbolKind.Property) 608Return GetMembers(Of EventSymbol)(GetMembers(), SymbolKind.Event) 631Case SymbolKind.Field 633Case SymbolKind.Method 641Case SymbolKind.Property 643Case SymbolKind.Event 645Case SymbolKind.NamedType 925If _container.Kind = SymbolKind.Namespace AndAlso _arity = 0 Then 1118If member.Kind = SymbolKind.Property Then 1561Private Shared Function GetIndexOfFirstMember(members As ImmutableArray(Of Symbol), kind As SymbolKind) As Integer 1575Private Overloads Shared Iterator Function GetMembers(Of TSymbol As Symbol)(members As ImmutableArray(Of Symbol), kind As SymbolKind, Optional offset As Integer = -1) As IEnumerable(Of TSymbol)

Symbols\Metadata\PE\PETypeParameterSymbol.vb (4)

102Return If(Me.ContainingSymbol.Kind = SymbolKind.Method, 186If _containingSymbol.Kind = SymbolKind.Method Then 317Dim typeParameters = If(_containingSymbol.Kind = SymbolKind.Method, 330Dim inherited = (_containingSymbol.Kind = SymbolKind.Method) AndAlso DirectCast(_containingSymbol, MethodSymbol).IsOverrides

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

81If arg.Key.Kind = SymbolKind.ErrorType AndAlso

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

127Case SymbolKind.ErrorType 131Case SymbolKind.DynamicType, 132SymbolKind.TypeParameter, 133SymbolKind.PointerType 137Case SymbolKind.NamedType 162Case SymbolKind.ArrayType

Symbols\MetadataOrSourceAssemblySymbol.vb (2)

83(corType.Kind = SymbolKind.ErrorType AndAlso 84_lazySpecialTypes(CInt(typeId)).Kind = SymbolKind.ErrorType))

Symbols\MethodSymbol.vb (3)

321If Me.IsAccessor AndAlso Me.AssociatedSymbol.Kind = SymbolKind.Property Then 488Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 490Return SymbolKind.Method

Symbols\MissingMetadataTypeSymbol.vb (1)

152If symbol.Kind = SymbolKind.Namespace AndAlso

Symbols\MissingNamespaceSymbol.vb (1)

63If _containingSymbol.Kind = SymbolKind.NetModule Then

Symbols\ModuleSymbol.vb (2)

108Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 110Return SymbolKind.NetModule

Symbols\NamedTypeSymbol.vb (6)

308If member.Kind = SymbolKind.Method Then 420If candidate.Kind = SymbolKind.Method Then 428If candidate.Kind = SymbolKind.Method Then 661Public Overrides ReadOnly Property Kind As SymbolKind ' Cannot seal this method because of the ErrorSymbol. 663Return SymbolKind.NamedType 1525If(ContainingSymbol?.Kind = SymbolKind.Namespace, False) AndAlso

Symbols\NamedTypeSymbolExtensions.vb (4)

24Friend Function FindMember(container As NamedTypeSymbol, symbolName As String, kind As SymbolKind, nameSpan As TextSpan, tree As SyntaxTree) As Symbol 36If kind = SymbolKind.Method Then 59If child.Kind = SymbolKind.Field OrElse child.Kind = SymbolKind.Property Then

Symbols\NamespaceOrTypeSymbol.vb (2)

33Return Kind = SymbolKind.Namespace 203If member.Kind = SymbolKind.Method Then

Symbols\NamespaceSymbol.vb (6)

130Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 132Return SymbolKind.Namespace 209If member.Kind = SymbolKind.Namespace Then 402If sym.Kind = SymbolKind.Namespace Then 498If member.Kind = SymbolKind.Method Then 519If member.Kind = SymbolKind.Method Then

Symbols\ObsoleteAttributeHelpers.vb (1)

161If symbol.IsAccessor() AndAlso (DirectCast(symbol, MethodSymbol).AssociatedSymbol).Kind = SymbolKind.Property Then

Symbols\ParameterSymbol.vb (2)

192Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 194Return SymbolKind.Parameter

Symbols\PreprocessingSymbol.vb (2)

40Public Overrides ReadOnly Property Kind As SymbolKind 42Return SymbolKind.Preprocessing

Symbols\PropertySymbol.vb (3)

215((fromMember.Kind = SymbolKind.Method AndAlso DirectCast(fromMember, MethodSymbol).IsAnyConstructor) OrElse 369Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 371Return SymbolKind.Property

Symbols\Retargeting\RetargetingNamespaceSymbol.vb (1)

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

Symbols\Retargeting\RetargetingSymbolTranslator.vb (14)

Symbols\Source\ImplementsHelper.vb (15)

26Case SymbolKind.Method 28Case SymbolKind.Property 30Case SymbolKind.Event 101If implementingSym.Kind = SymbolKind.Method Then 103ElseIf implementingSym.Kind = SymbolKind.Property Then 124Dim implementingSymIsEvent = (implementingSym.Kind = SymbolKind.Event) 134Debug.Assert(implementedMember.Kind = SymbolKind.Event) 201If implementingSym.Kind = SymbolKind.Event Then 344If coClassContext AndAlso (implementingSym.Kind = SymbolKind.Event) <> (foundMember.Kind = SymbolKind.Event) Then 365ElseIf foundMember.Kind = SymbolKind.Property Then 428Case SymbolKind.Method 434Case SymbolKind.Property 440Case SymbolKind.Event 470If implementedSym.Kind = SymbolKind.Property Then

Symbols\Source\LambdaSymbol.vb (6)

131Case SymbolKind.Field 133Case SymbolKind.Property 135Case SymbolKind.Method 232Case SymbolKind.Field, SymbolKind.Property, SymbolKind.Method

Symbols\Source\LocalSymbol.vb (6)

105Debug.Assert(container.Kind = SymbolKind.Method OrElse 106container.Kind = SymbolKind.Field OrElse 107container.Kind = SymbolKind.Property, 155Debug.Assert((Me.IsFunctionValue AndAlso _container.Kind = SymbolKind.Method AndAlso DirectCast(_container, MethodSymbol).MethodKind = MethodKind.LambdaMethod) OrElse type.Equals(ComputeType())) 186Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 188Return SymbolKind.Local

Symbols\Source\OverloadingHelper.vb (6)

28Public Sub SetMetadataNameForAllOverloads(name As String, kind As SymbolKind, container As NamedTypeSymbol) 29Debug.Assert(kind = SymbolKind.Method OrElse kind = SymbolKind.Property) 79kind As SymbolKind, 148Private Function GetBaseMemberMetadataName(name As String, kind As SymbolKind, container As NamedTypeSymbol) As String 189Private Function IsCandidateMember(member As Symbol, kind As SymbolKind) As Boolean

Symbols\Source\OverrideHidingHelper.vb (19)

Symbols\Source\RangeVariableSymbol.vb (2)

34Public Overrides ReadOnly Property Kind As SymbolKind 36Return SymbolKind.RangeVariable

Symbols\Source\SourceDeclareMethodSymbol.vb (1)

59OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Method, m_containingType)

Symbols\Source\SourceFile.vb (1)

69Debug.Assert(Not memberImports.Any(Function(i) i.NamespaceOrType.Kind = SymbolKind.ErrorType))

Symbols\Source\SourceMemberContainerTypeSymbol.vb (28)

Symbols\Source\SourceMemberFieldSymbol.vb (1)

230(varType.Kind = SymbolKind.TypeParameter AndAlso varType.IsReferenceType)) Then

Symbols\Source\SourceMemberMethodSymbol.vb (2)

109OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Method, m_containingType) 960If symbol.Kind = SymbolKind.Property Then

Symbols\Source\SourceMethodSymbol.vb (7)

1058container.FindMember(propertyIdentifier.ValueText, SymbolKind.Property, propertyIdentifier.Span, tree), 1089container.FindMember(eventIdentifier.ValueText, SymbolKind.Event, eventIdentifier.Span, tree), 1125Return container.FindMember(propertyIdentifier.ValueText, SymbolKind.Property, propertyIdentifier.Span, tree) 1129Return container.FindMember(eventIdentifier.ValueText, SymbolKind.Event, eventIdentifier.Span, tree) 1133Return container.FindMember(delegateIdentifier.ValueText, SymbolKind.NamedType, delegateIdentifier.Span, tree) 1137SymbolKind.Method, GetMethodLocationFromSyntax(syntax), tree), MethodSymbol) 1787If Me.IsAccessor() AndAlso Me.AssociatedSymbol.Kind = SymbolKind.Event Then

Symbols\Source\SourceModuleSymbol.vb (5)

312Case SymbolKind.Namespace 316Case SymbolKind.NamedType 1157Case SymbolKind.Property 1177Case SymbolKind.NamedType 1189Case SymbolKind.Namespace

Symbols\Source\SourceNamedTypeSymbol.vb (9)

82If containingSymbol.Kind = SymbolKind.Namespace AndAlso 95If containingSymbol.Kind = SymbolKind.NamedType Then 504Case SymbolKind.Namespace 511Case SymbolKind.NamedType 539If s.Kind = SymbolKind.Namespace Then 2285If ContainingSymbol.Kind = SymbolKind.Namespace AndAlso attrData.IsTargetAttribute(AttributeDescription.CaseInsensitiveExtensionAttribute) Then 2413If member.Kind = SymbolKind.Event AndAlso 2487If Not m.IsShared And m.Kind = SymbolKind.Field Then 2681If member.Kind = SymbolKind.Method Then

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (13)

103If m.Kind = SymbolKind.Method Then 376Dim memberKind As SymbolKind = member.Kind 380Case SymbolKind.Field, SymbolKind.NamedType 382Case SymbolKind.Method 394Case SymbolKind.Property 449Case SymbolKind.Event 452Case SymbolKind.Method 495If target.Kind <> SymbolKind.Property OrElse Not DirectCast(target, PropertySymbol).IsDefault Then 547Case SymbolKind.Method 566Case SymbolKind.Property 1338If attributeSource.Kind = SymbolKind.Method Then 1379If attributeSource.Kind = SymbolKind.Method Then

Symbols\Source\SourceNamedTypeSymbol_GroupClass.vb (5)

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

Symbols\Source\SourceParameterSymbol.vb (5)

186If containingSymbol.Kind = SymbolKind.Method AndAlso DirectCast(containingSymbol, MethodSymbol).MethodKind = MethodKind.DeclareMethod Then 203Case SymbolKind.Property 206Case SymbolKind.Method 450If container.Kind = SymbolKind.Method Then 495ContainingSymbol.Kind = SymbolKind.Method AndAlso

Symbols\Source\SourcePropertySymbol.vb (1)

416OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Property, _containingType)

Symbols\SubstitutedNamedType.vb (10)

368Case SymbolKind.NamedType 371Case SymbolKind.Method 374Case SymbolKind.Property 381Case SymbolKind.Event 390Case SymbolKind.Field 451Case SymbolKind.NamedType 454Case SymbolKind.Method 488Case SymbolKind.Property 491Case SymbolKind.Event 494Case SymbolKind.Field

Symbols\SubstitutedTypeParameterSymbol.vb (1)

89Return If(_containingSymbol.Kind = SymbolKind.Method,

Symbols\Symbol.vb (30)

Symbols\Symbol_Attributes.vb (17)

62Case SymbolKind.Assembly 65Case SymbolKind.Event 68Case SymbolKind.Field 71Case SymbolKind.Method 92Case SymbolKind.Property 95Case SymbolKind.NamedType 120Case SymbolKind.NetModule 123Case SymbolKind.Parameter 126Case SymbolKind.TypeParameter 258Dim sourceAssembly = DirectCast(If(Me.Kind = SymbolKind.Assembly, Me, Me.ContainingAssembly), SourceAssemblySymbol) 522Debug.Assert(Me.Kind = SymbolKind.Method OrElse Me.Kind = SymbolKind.Property) 532Me.Kind = SymbolKind.Event AndAlso DirectCast(Me, SourceEventSymbol).AssociatedField IsNot Nothing Then 548If Me.Kind = SymbolKind.Method Then 590Case SymbolKind.Assembly, SymbolKind.NamedType, SymbolKind.Method

Symbols\SymbolExtensions.vb (43)

Symbols\Tuples\TupleTypeSymbol.vb (16)

143Public Overrides ReadOnly Property Kind As SymbolKind 145Return SymbolKind.NamedType 666If member.Kind <> SymbolKind.Field Then 714Case SymbolKind.Method 719Case SymbolKind.Field 788Case SymbolKind.NamedType 791Case SymbolKind.Property 796Case SymbolKind.Event 894Dim kind As SymbolKind = symbol.Kind 896Case SymbolKind.[Event] 908Case SymbolKind.Field 914Case SymbolKind.Method 917Case SymbolKind.Property 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\TypeParameterSymbol.vb (2)

140Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 142Return SymbolKind.TypeParameter

Symbols\TypeSubstitution.vb (7)

563(targetGenericDefinition.Kind = SymbolKind.Method AndAlso 566Debug.Assert((targetGenericDefinition.Kind = SymbolKind.Method AndAlso 569((targetGenericDefinition.Kind = SymbolKind.NamedType OrElse targetGenericDefinition.Kind = SymbolKind.ErrorType) AndAlso 596If memberDefinition.Kind = SymbolKind.Method Then 758If targetGenericDefinition.Kind = SymbolKind.Method Then 814If targetGenericDefinition.Kind = SymbolKind.Method Then

Symbols\TypeSymbol.vb (4)

378If Me.Kind <> SymbolKind.ErrorType Then 686Case SymbolKind.Method 692Case SymbolKind.Property 698Case SymbolKind.Event

Symbols\TypeSymbolExtensions.vb (12)

134Return type.Kind = SymbolKind.NamedType AndAlso DirectCast(type, NamedTypeSymbol).IsInterface 158Return type.Kind = SymbolKind.ErrorType 164Return type.Kind = SymbolKind.ArrayType 191type.Kind = SymbolKind.NamedType AndAlso 212type.Kind = SymbolKind.NamedType AndAlso 227Return type.Kind = SymbolKind.TypeParameter 371If this.Kind = SymbolKind.ArrayType Then 381While this.Kind = SymbolKind.ArrayType 490If this.Kind = SymbolKind.TypeParameter Then 497If this.Kind = SymbolKind.NamedType AndAlso Not DirectCast(this, NamedTypeSymbol).IsInterface Then 524If possiblyArrayType.Kind = SymbolKind.ArrayType Then 1234If container.Kind <> SymbolKind.Namespace Then

Symbols\UnboundGenericType.vb (1)

508If member.Kind = SymbolKind.NamedType Then

Symbols\WellKnownMembers.vb (19)

Utilities\TypeUnification.vb (8)

93Case SymbolKind.ArrayType 106Case SymbolKind.NamedType, SymbolKind.ErrorType 150Case SymbolKind.TypeParameter 241Case SymbolKind.ArrayType 243Case SymbolKind.NamedType, SymbolKind.ErrorType 257Case SymbolKind.TypeParameter

Microsoft.CodeAnalysis.Workspaces (313)

Editing\SyntaxGenerator.cs (14)

528var invoke = symbol.Type.GetMembers("Invoke").FirstOrDefault(m => m.Kind == SymbolKind.Method) as IMethodSymbol; 730case SymbolKind.Field: 733case SymbolKind.Property: 737case SymbolKind.Event: 741case SymbolKind.Method: 761case SymbolKind.Parameter: 764case SymbolKind.NamedType: 798members: type.GetMembers().SelectAsArray(s => s.Kind == SymbolKind.Field, Declaration)), 873case SymbolKind.Field: 874case SymbolKind.Property: 875case SymbolKind.Event: 876case SymbolKind.Parameter: 879case SymbolKind.Method: 893case SymbolKind.NamedType:

FindSymbols\Declarations\DeclarationFinder.cs (5)

99if (IsOn(filter, SymbolFilter.Namespace) && symbol.Kind == SymbolKind.Namespace) 120return symbol.Kind is SymbolKind.Method or 121SymbolKind.Property or 122SymbolKind.Event or 123SymbolKind.Field;

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

86return field is { IsImplicitlyDeclared: true, AssociatedSymbol.Kind: SymbolKind.Property }

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

34SymbolKind.Namespace => !((INamespaceSymbol)symbol).IsGlobalNamespace, 35SymbolKind.NamedType => true, 36SymbolKind.Method => true, 37SymbolKind.Field => true, 38SymbolKind.Property => true, 39SymbolKind.Event => true,

FindSymbols\ReferenceLocationExtensions.cs (2)

82if (current.Kind == SymbolKind.Field) 87if (current.Kind == SymbolKind.Property)

FindSymbols\SymbolFinder_Callers.cs (4)

81if (symbol.Kind is SymbolKind.Event or 82SymbolKind.Method or 83SymbolKind.Property or 84SymbolKind.Field)

FindSymbols\SymbolFinder_Helpers.cs (2)

43if (searchSymbol.Kind == SymbolKind.Namespace && symbolToMatch.Kind == SymbolKind.Namespace)

Recommendations\AbstractRecommendationService.cs (7)

73case SymbolKind.NamedType: 82case SymbolKind.Method: 96case SymbolKind.Event: 97case SymbolKind.Field: 98case SymbolKind.Property: 102case SymbolKind.TypeParameter: 117return symbol.Kind == SymbolKind.Field ||

Recommendations\AbstractRecommendationServiceRunner.cs (2)

136if (!parameterTypeSymbols.Any(static t => t.IsKind(SymbolKind.TypeParameter))) 155if (parameterTypeSymbol.IsKind<ITypeParameterSymbol>(SymbolKind.TypeParameter, out var typeParameter))

Rename\ConflictEngine\ConflictResolver.cs (13)

233if (renamedSymbol.ContainingSymbol.IsKind(SymbolKind.NamedType)) 247.Where(s => !s.MatchesKind(SymbolKind.Method, SymbolKind.Property) || 248!renamedSymbol.MatchesKind(SymbolKind.Method, SymbolKind.Property)); 253.Where(s => s.Kind != SymbolKind.Method || renamedSymbol.Kind != SymbolKind.Method); 259if (renamedSymbol.IsKind(SymbolKind.Namespace) && renamedSymbol.ContainingSymbol.IsKind(SymbolKind.Namespace)) 263!s.IsKind(SymbolKind.Namespace) && 269if (renamedSymbol.IsKind(SymbolKind.NamedType) && renamedSymbol.ContainingSymbol is INamespaceOrTypeSymbol) 275var conflictingSymbolLocations = otherThingsNamedTheSame.Where(s => !s.IsKind(SymbolKind.Namespace)); 276if (otherThingsNamedTheSame.Any(s => s.IsKind(SymbolKind.Namespace)))

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

649newReferencedSymbols = newReferencedSymbols.WhereAsArray(a => a.Kind != SymbolKind.Alias);

Rename\RenameUtilities.cs (7)

58symbols = symbols.WhereAsArray(s => s.Kind != SymbolKind.Alias); 76symbol.Kind is SymbolKind.Local or 77SymbolKind.Label or 78SymbolKind.RangeVariable or 79SymbolKind.Parameter; 197if (containingType.Kind == SymbolKind.NamedType) 225if (symbol.Kind == SymbolKind.Method &&

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (9)

Shared\Extensions\IFindReferencesResultExtensions.cs (2)

22return definition.IsKind(SymbolKind.Namespace) 67if (definition.Kind == SymbolKind.Property)

Shared\Extensions\INamespaceSymbolExtensions.cs (1)

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

Shared\Extensions\ISymbolExtensions.cs (4)

61if (symbol.Kind == SymbolKind.Namespace) 279case SymbolKind.Method: 280case SymbolKind.Property: 281case SymbolKind.Event:

Shared\Extensions\ITypeSymbolExtensions.cs (3)

49if (interfaceMember.Kind is not SymbolKind.Event and 50not SymbolKind.Method and 51not SymbolKind.Property)

Shared\Extensions\SemanticModelExtensions.cs (1)

123else if (!declaredSymbol.IsKind(SymbolKind.RangeVariable))

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

Workspace\Solution\SolutionCompilationState.RegularCompilationTracker.cs (3)

108Debug.Assert(symbol.Kind is SymbolKind.Assembly or SymbolKind.NetModule or SymbolKind.DynamicType);

Workspace\Solution\SolutionCompilationState.SymbolToProjectId.cs (4)

134if (symbol.IsKind(SymbolKind.Namespace, out INamespaceSymbol? ns)) 144else if (symbol.IsKind(SymbolKind.Assembly) || 145symbol.IsKind(SymbolKind.NetModule) || 146symbol.IsKind(SymbolKind.DynamicType))

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)

Options\NamingStyleTestUtilities.cs (1)

76SymbolKind symbolKind => new SymbolSpecification.SymbolKindOrTypeKind(symbolKind),

Microsoft.CodeAnalysis.Workspaces.UnitTests (54)

EditorConfigParsing\NamingStyleParserTests.cs (15)

FindReferencesTests.cs (7)

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

Options\EditorConfigNamingStyleParserTests.cs (27)

Options\NamingStylePreferencesTests.cs (1)

191[InlineData(typeof(SymbolKind))]

SymbolKeyTests.cs (4)

1088Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1124Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1173Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1222Assert.Equal(SymbolKind.ErrorType, propType.Kind);

Microsoft.DotNet.CodeAnalysis (5)

Analyzers\MembersMustExistAnalyzer.cs (4)

62context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method, SymbolKind.Event); 63context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Field, SymbolKind.Event);

Analyzers\PinvokeAnalyzer.cs (1)

32obj.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);

Microsoft.Extensions.Logging.Generators (4)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Extensions.Options.SourceGeneration (8)

Parser.cs (2)

82if (modelType.Kind == SymbolKind.ErrorType) 201.Where(m => m.Kind == SymbolKind.Method)

ParserUtilities.cs (2)

83property.Kind == SymbolKind.Property && !property.IsStatic && property.GetMethod != null && property.Parameters.IsEmpty)) 96property.Type.SpecialType == returnType && property.Kind == SymbolKind.Property &&

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Gen.Logging (12)

Parsing\Parser.cs (1)

152&& paramSymbol.Type.Kind != SymbolKind.TypeParameter)

Parsing\Parser.LogProperties.cs (3)

123foreach (var property in members.Where(m => m.Kind == SymbolKind.Property).Cast<IPropertySymbol>()) 318&& property.Type.Kind != SymbolKind.TypeParameter 337symType.Kind == SymbolKind.NamedType &&

Parsing\Parser.Records.cs (1)

146extractedType.Kind == SymbolKind.NamedType &&

Parsing\Parser.TagProvider.cs (2)

88var methodSymbols = providerType.GetMembers(providerMethodName).Where(m => m.Kind == SymbolKind.Method).Cast<IMethodSymbol>(); 184while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Parsing\TypeSymbolExtensions.cs (1)

82if (current.GetMembers("ToString").Where(m => m.Kind == SymbolKind.Method && m.DeclaredAccessibility == Accessibility.Public).Cast<IMethodSymbol>().Any(m => m.Parameters.Length == 0))

src\Generators\Shared\RoslynExtensions.cs (4)

150case SymbolKind.Alias: 155case SymbolKind.Parameter: 159case SymbolKind.TypeParameter: 164while (symbol is not null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Gen.Logging.Unit.Tests (1)

LogParserUtilitiesTests.cs (1)

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

Microsoft.Gen.MetadataExtractor (2)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (2)

697case SymbolKind.Property: 705case SymbolKind.Field:

Microsoft.Gen.Metrics (6)

Parser.cs (2)

697case SymbolKind.Property: 705case SymbolKind.Field:

src\Generators\Shared\RoslynExtensions.cs (4)

150case SymbolKind.Alias: 155case SymbolKind.Parameter: 159case SymbolKind.TypeParameter: 164while (symbol is not null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Gen.MetricsReports (2)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (2)

697case SymbolKind.Property: 705case SymbolKind.Field:

Microsoft.Interop.ComInterfaceGenerator (9)

Analyzers\AddGeneratedComClassAnalyzer.cs (1)

61}, SymbolKind.NamedType);

Analyzers\ConvertComImportToGeneratedComInterfaceAnalyzer.cs (1)

146}, SymbolKind.NamedType);

Analyzers\GeneratedComInterfaceAttributeAnalyzer.cs (1)

46}, SymbolKind.NamedType);

ComMethodInfo.cs (2)

52case { Kind: SymbolKind.Property }: 55case { Kind: SymbolKind.Event }:

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Interop.LibraryImportGenerator (6)

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

63context.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, libraryImportAttrType, env), SymbolKind.Method);

Analyzers\ShapeBreakingDiagnosticSuppressor.cs (1)

38if (diagnosedSymbol.Kind != SymbolKind.Method)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Interop.LibraryImportGenerator.Downlevel (4)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Interop.SourceGeneration (4)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

Microsoft.Maui.Controls.BindingSourceGen (2)

InvocationParser.cs (1)

69 || methodSymbol.Kind != SymbolKind.Method

ITypeSymbolExtensions.cs (1)

23 IsGenericParameter: typeSymbol.Kind == SymbolKind.TypeParameter, //TODO: Add support for generic parameters

Microsoft.ML.CodeAnalyzer.Tests (1)

Code\RelaxTestNamingTest.cs (1)

116context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);

Microsoft.ML.InternalCodeAnalyzer (8)

BaseTestClassAnalyzer.cs (1)

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

BestFriendOnPublicDeclarationsAnalyzer.cs (4)

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

ContractsCheckNameofFixProvider.cs (1)

139foreach (IFieldSymbol s in type.GetMembers().Where(p => p.Kind == SymbolKind.Field))

InstanceInitializerAnalyzer.cs (2)

36context.RegisterSymbolAction(AnalyzeField, SymbolKind.Field); 37context.RegisterSymbolAction(AnalyzeProperty, SymbolKind.Property);

Microsoft.VisualStudio.LanguageServices (49)

CallHierarchy\CallHierarchyProvider.cs (8)

56if (symbol.Kind is SymbolKind.Method or 57SymbolKind.Property or 58SymbolKind.Event or 59SymbolKind.Field) 101if (symbol.Kind is SymbolKind.Property or 102SymbolKind.Event or 103SymbolKind.Method) 140if (symbol.Kind == SymbolKind.Field)

CallHierarchy\Finders\AbstractCallFinder.cs (1)

158if (caller.CallingSymbol.Kind == SymbolKind.Field)

CommonControls\MemberSelectionViewModel.cs (2)

140var fields = Members.WhereAsArray(memberViewModel => memberViewModel.Symbol.IsKind(SymbolKind.Field)); 142WhereAsArray(memberViewModel => !memberViewModel.Symbol.IsKind(SymbolKind.Field) && !memberViewModel.Symbol.IsAbstract);

ExtractClass\VisualStudioExtractClassOptionsService.cs (1)

64IsMakeAbstractCheckable = !member.IsKind(SymbolKind.Field) && !member.IsAbstract,

Implementation\ContainedLanguageRefactorNotifyService.cs (4)

81else if (symbol.Kind is SymbolKind.Event or 82SymbolKind.Field or 83SymbolKind.Method or 84SymbolKind.Property)

Library\ClassView\AbstractSyncClassViewCommandHandler.cs (5)

89=> symbol.Kind is SymbolKind.Event or 90SymbolKind.Field or 91SymbolKind.Method or 92SymbolKind.NamedType or 93SymbolKind.Property;

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (6)

206case SymbolKind.Method: 210case SymbolKind.Field: 214case SymbolKind.Property: 218case SymbolKind.Event: 444|| symbol.Kind is SymbolKind.Method or SymbolKind.Property;

Library\ObjectBrowser\AbstractListItemFactory.cs (1)

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

Library\ObjectBrowser\Lists\MemberListItem.cs (4)

19case SymbolKind.Event: 23case SymbolKind.Field: 38case SymbolKind.Method: 47case SymbolKind.Property:

Library\ObjectBrowser\Lists\SymbolListItem.cs (2)

32_supportsGoToDefinition = symbol.Kind != SymbolKind.Namespace; 33_supportsFindAllReferences = symbol.Kind != SymbolKind.Namespace;

Library\VsNavInfo\NavInfoFactory.cs (4)

49if (symbol.Kind is SymbolKind.Event or 50SymbolKind.Field or 51SymbolKind.Method or 52SymbolKind.Property)

PullMemberUp\VisualStudioPullMemberUpService.cs (1)

53IsMakeAbstractCheckable = !member.IsKind(SymbolKind.Field) && !member.IsAbstract,

Utilities\MemberSymbolViewModel.cs (1)

23public Visibility MakeAbstractVisibility => Symbol.Kind == SymbolKind.Field || Symbol.IsAbstract ? Visibility.Hidden : Visibility.Visible;

Venus\ContainedLanguageCodeSupport.cs (9)

103if (eventType.Kind != SymbolKind.NamedType) 177if (eventType.Kind != SymbolKind.NamedType || ((INamedTypeSymbol)eventType).DelegateInvokeMethod == null) 371if (member.Kind != SymbolKind.Method) 400return member.Kind == SymbolKind.Event; 403return member.Kind == SymbolKind.Method; 447if (member.Kind == SymbolKind.Method) 451else if (member.Kind == SymbolKind.Event) 464var members = type.GetMembers(memberName).Where(m => m.Kind == SymbolKind.Method); 496return semanticModel.LookupSymbols(typeLocation.SourceSpan.Start, objectType, nameOfEvent).SingleOrDefault(m => m.Kind == SymbolKind.Event);

Microsoft.VisualStudio.LanguageServices.CSharp (18)

CodeModel\CSharpCodeModelService.cs (9)

2985protected override Accessibility GetDefaultAccessibility(SymbolKind targetSymbolKind, CodeGenerationDestination destination) 2989case SymbolKind.Field: 2990case SymbolKind.Method: 2991case SymbolKind.Property: 2992case SymbolKind.Event: 2995case SymbolKind.NamedType: 3604symbol == null || symbol.Kind != SymbolKind.Method) 3644symbol == null || symbol.Kind != SymbolKind.Property) 3821if (typeSymbol.Kind != SymbolKind.NamedType ||

CodeModel\CSharpCodeModelService_Prototype.cs (6)

29case SymbolKind.Field: 31case SymbolKind.Method: 33case SymbolKind.Property: 35case SymbolKind.Event: 37case SymbolKind.NamedType: 58case VariableDeclaratorSyntax variableDeclarator when symbol.Kind == SymbolKind.Field:

LanguageService\CSharpHelpContextService.cs (3)

568if (symbol.MatchesKind(SymbolKind.Alias, SymbolKind.Local, SymbolKind.Parameter))

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (45)

GlyphExtensionsTests.cs (45)

Microsoft.VisualStudio.LanguageServices.Implementation (51)

CodeModel\AbstractCodeModelObject_CodeGen.cs (7)

41accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Method, destination), 72accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination), 117accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Event, destination), 135accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination), 150accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Method, destination), 216accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination), 252accessibility: CodeModelService.GetAccessibility(access, SymbolKind.NamedType, destination),

CodeModel\AbstractCodeModelService.cs (8)

210case SymbolKind.Event: 212case SymbolKind.Field: 214case SymbolKind.Method: 216case SymbolKind.Namespace: 218case SymbolKind.NamedType: 237case SymbolKind.Property: 742protected abstract Accessibility GetDefaultAccessibility(SymbolKind targetSymbolKind, CodeGenerationDestination destination); 744public Accessibility GetAccessibility(EnvDTE.vsCMAccess access, SymbolKind targetSymbolKind, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified)

CodeModel\Collections\ExternalOverloadsCollection.cs (1)

62if (method.Kind != SymbolKind.Method)

CodeModel\Collections\OverloadsCollection.cs (1)

66if (method.Kind != SymbolKind.Method)

CodeModel\ExternalElements\ExternalCodeFunction.cs (1)

80.Where(m => m.Kind == SymbolKind.Method);

CodeModel\ExternalElements\ExternalCodeVariable.cs (2)

36case SymbolKind.Field: 38case SymbolKind.Property:

CodeModel\ICodeModelService.cs (1)

278Accessibility GetAccessibility(EnvDTE.vsCMAccess access, SymbolKind targetSymbolKind, CodeGenerationDestination destination = CodeGenerationDestination.Unspecified);

CodeModel\InternalElements\CodeFunction.cs (1)

129.Where(m => m.Kind == SymbolKind.Method);

CodeModel\InternalElements\CodeVariable.cs (2)

67case SymbolKind.Field: 69case SymbolKind.Property:

CodeModel\MetadataNameHelpers.cs (5)

65if (typeSymbol.Kind == SymbolKind.TypeParameter) 97case SymbolKind.Namespace: 106case SymbolKind.NamedType: 110case SymbolKind.ArrayType: 114case SymbolKind.PointerType:

CodeModel\MethodXml\AbstractMethodXmlBuilder.cs (6)

349case SymbolKind.Event: 350case SymbolKind.Field: 352case SymbolKind.Local: 353case SymbolKind.Parameter: 355case SymbolKind.Method: 357case SymbolKind.Property:

Options\Style\NamingPreferences\SymbolSpecification\SymbolSpecificationViewModel.cs (16)

Microsoft.VisualStudio.LanguageServices.Xaml (6)

Features\InlineRename\IXamlRenameInfo.cs (1)

45SymbolKind Kind { get; }

Features\InlineRename\XamlEditorInlineRenameService.cs (5)

119private static Glyph FromSymbolKind(SymbolKind kind) 125case SymbolKind.Namespace: 128case SymbolKind.NamedType: 131case SymbolKind.Property: 134case SymbolKind.Event:

Roslyn.Diagnostics.Analyzers (335)

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (3)

51context.RegisterSymbolAction(context => AnalyzeField(context, nonDefaultableAttribute, knownNonDefaultableTypes), SymbolKind.Field); 52context.RegisterSymbolAction(context => AnalyzeNamedType(context, nonDefaultableAttribute, knownNonDefaultableTypes), SymbolKind.NamedType); 66if (member.Kind != SymbolKind.Field)

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\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (3)

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

TestExportsShouldNotBeDiscoverable.cs (1)

68}, SymbolKind.NamedType);

Roslyn.Diagnostics.Analyzers.UnitTests (1)

RelaxTestNamingSuppressorTests.cs (1)

117context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);

Roslyn.Diagnostics.CSharp.Analyzers (29)

CSharpAvoidOptSuffixForNullableEnableCode.cs (2)

93SymbolKind.Property => !symbol.IsOverride 96SymbolKind.Parameter => symbol.ContainingSymbol != null

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

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

1224return typeInfo.Type?.Kind == SymbolKind.ArrayType; 1232if (symbol?.Kind == SymbolKind.Field)

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true) 281if (semanticModel.GetSymbolInfo(n, cancellationToken).Symbol.IsKind(SymbolKind.Local) == true)

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

84var members = GetMembers(namedType).WhereAsArray(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s));

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

56if (symbol != null && symbol.Kind != SymbolKind.Namespace && model.GetSymbolInfo(namespacePart).Symbol is INamespaceSymbol) 216if (symbol?.Kind == SymbolKind.NamedType)

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

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

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

114if (targetType.Kind == SymbolKind.DynamicType)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\LanguageServices\CSharpSemanticFactsService.cs (2)

49visibleSymbols = visibleSymbols.WhereAsArray(s => !s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter));

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

Roslyn.Test.PdbUtilities (1)

EditAndContinue\EditAndContinueTest.GenerationVerifier.cs (1)

238.Single(e => e.Key.ToString() == typeName).Value.Where(s => s.Kind == SymbolKind.Field)

SemanticSearch.BuildTask (3)

GenerateFilteredReferenceAssembliesTask.cs (3)

352SymbolKind.Field => SymbolKindFlags.Field, 353SymbolKind.Method => SymbolKindFlags.Method, 354SymbolKind.NamedType => SymbolKindFlags.NamedType,

System.Private.CoreLib.Generators (3)

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (3)

154if (member.Kind == SymbolKind.Property) 186}, SymbolKind.Method); 276if (symbolInfo.Symbol.Kind != SymbolKind.Property)

System.Text.Json.SourceGeneration (4)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

System.Text.RegularExpressions.Generator (4)

src\libraries\Common\src\Roslyn\GetBestTypeByMetadataName.cs (4)

101case SymbolKind.Alias: 106case SymbolKind.Parameter: 110case SymbolKind.TypeParameter: 115while (symbol != null && symbol.Kind != SymbolKind.Namespace)

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

System\Windows\Forms\CSharp\Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationAnalyzer.cs (1)

22context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Property);

Test.Utilities (220)

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

Text.Analyzers (326)

EnumsShouldHavePluralNames.cs (1)

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

IdentifiersShouldBeSpelledCorrectly.cs (28)

254SymbolKind.Namespace, 255SymbolKind.NamedType, 256SymbolKind.Method, 257SymbolKind.Property, 258SymbolKind.Event, 259SymbolKind.Field, 260SymbolKind.Parameter); 489SymbolKind.Assembly => symbol.CreateDiagnostic(AssemblyRule, misspelledWord, symbol.Name), 490SymbolKind.Namespace => symbol.CreateDiagnostic(NamespaceRule, misspelledWord, symbol.ToDisplayString()), 491SymbolKind.NamedType => symbol.CreateDiagnostic(TypeRule, misspelledWord, symbol.ToDisplayString()), 492SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field 494SymbolKind.Parameter => symbol.ContainingType.TypeKind == TypeKind.Delegate 497SymbolKind.TypeParameter => symbol.ContainingSymbol.Kind == SymbolKind.Method 500SymbolKind.Local => symbol.CreateDiagnostic(VariableRule, misspelledWord, symbol.ToDisplayString()), 509SymbolKind.Assembly => symbol.CreateDiagnostic(AssemblyMoreMeaningfulNameRule, symbolName), 510SymbolKind.Namespace => symbol.CreateDiagnostic(NamespaceMoreMeaningfulNameRule, symbolName), 511SymbolKind.NamedType => symbol.CreateDiagnostic(TypeMoreMeaningfulNameRule, symbolName), 512SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field 514SymbolKind.Parameter => symbol.ContainingType.TypeKind == TypeKind.Delegate 517SymbolKind.TypeParameter => symbol.ContainingSymbol.Kind == SymbolKind.Method

src\Compilers\Core\Portable\SourceGeneration\GeneratedCodeUtilities.cs (1)

27if (symbol.Kind != SymbolKind.Namespace)

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

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

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

src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (4)

src\RoslynAnalyzers\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

57if (operationBlockAnalysisContext.OwningSymbol.Kind != SymbolKind.Method)

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

374if (symbol.ContainingSymbol?.Kind == SymbolKind.Method &&

src\RoslynAnalyzers\Utilities\Compiler\Extensions\ISymbolExtensions.cs (2)

220SymbolKind.Local => ((ILocalSymbol)symbol).Type, 222SymbolKind.Parameter => ((IParameterSymbol)symbol).Type,

src\RoslynAnalyzers\Utilities\Compiler\Options\AnalyzerOptionsExtensions.cs (7)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.AnalysisData.cs (2)

180if (symbol.Kind == SymbolKind.Discard) 204if (symbol.Kind == SymbolKind.Discard)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\EditorConfig\EditorConfigNamingStyleParser_SymbolSpec.cs (14)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\NamingStyleRules.cs (4)

15private readonly ImmutableArray<SymbolKind> _symbolKindsThatCanBeOverridden = 16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\NamingStyles\Serialization\SymbolSpecification.cs (27)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (5)

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

77else if (symbol.Kind != SymbolKind.Namespace)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.BodyLevelSymbolKey.cs (4)

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

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

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

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

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

598case SymbolKind.NamedType: 609case SymbolKind.TypeParameter:

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Extensions\Symbols\SignatureComparer.cs (6)

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

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

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationAbstractMethodSymbol.cs (2)

74public override SymbolKind Kind => SymbolKind.Method;

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

42public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationArrayTypeSymbol.cs (2)

45public override SymbolKind Kind => SymbolKind.ArrayType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationEventSymbol.cs (2)

40public override SymbolKind Kind => SymbolKind.Event;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationFieldSymbol.cs (2)

44public override SymbolKind Kind => SymbolKind.Field;

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

65public override SymbolKind Kind => SymbolKind.NamedType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationNamespaceSymbol.cs (2)

25public override SymbolKind Kind => SymbolKind.Namespace;

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

45public override SymbolKind Kind => SymbolKind.Parameter;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPointerTypeSymbol.cs (2)

21public override SymbolKind Kind => SymbolKind.PointerType;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationPropertySymbol.cs (2)

51public override SymbolKind Kind => SymbolKind.Property;

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

73public abstract SymbolKind Kind { get; }

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationTypeParameterSymbol.cs (2)

49public override SymbolKind Kind => SymbolKind.TypeParameter;

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

31s.Kind is SymbolKind.Local or 32SymbolKind.Parameter or 33SymbolKind.RangeVariable or 34SymbolKind.Field or 35SymbolKind.Property || 36s is { Kind: SymbolKind.NamedType, IsStatic: true };

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

118return symbol.Kind == SymbolKind.Method &&

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