SymbolKind

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

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

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

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

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

310if (analysisEntity.Symbol?.Kind == SymbolKind.Field) 1018(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)

312Debug.Assert(symbol.Kind is SymbolKind.Local or SymbolKind.Parameter or SymbolKind.Field or SymbolKind.Property); 447symbol?.Kind != SymbolKind.Local && 448symbol?.Kind != SymbolKind.Parameter) 518Debug.Assert(symbol.Kind == SymbolKind.Local || symbol.Kind == SymbolKind.Parameter || symbol.IsStatic || symbol.IsLambdaOrLocalFunction()); 533(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)

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

Microsoft.CodeAnalysis.BannedApiAnalyzers (90)

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)

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

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

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

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

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

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

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

SymbolIsBannedAnalyzerBase.cs (5)

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

Microsoft.CodeAnalysis.CodeStyle (216)

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)

768case SymbolKind.NamedType: 769case SymbolKind.Method: 770case SymbolKind.Field: 771case SymbolKind.Property: 772case SymbolKind.Event:

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

228compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 278}, SymbolKind.NamedType); 800case SymbolKind.Method: 901case SymbolKind.Field: 904case SymbolKind.Property: 912case 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\INamedTypeSymbolExtensions.cs (6)

200m.Kind != SymbolKind.NamedType && 211if (member.Kind != SymbolKind.Property) 301return type.GetMembers().WhereAsArray(m => m.Kind != SymbolKind.NamedType && 311if (member.Kind != SymbolKind.Property) 484case SymbolKind.Field: 495case SymbolKind.Property:

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

36case SymbolKind.Alias: 41case SymbolKind.Parameter: 45case SymbolKind.TypeParameter: 50while (symbol != null && symbol.Kind != SymbolKind.Namespace) 117if (symbol.Kind is SymbolKind.Event or SymbolKind.Property) 148if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 187if (symbol.Kind == SymbolKind.Event) 192if (symbol.Kind == SymbolKind.Property) 233=> symbol?.Kind == SymbolKind.ArrayType; 241public static bool IsKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind) 244public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind) 247public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind1, SymbolKind kind2) 253public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, SymbolKind kind1, SymbolKind kind2, SymbolKind kind3) 259public static bool MatchesKind([NotNullWhen(true)] this ISymbol? symbol, params SymbolKind[] kinds) 269=> symbol?.Kind == SymbolKind.Field && symbol.ContainingType.IsEnumType(); 351SymbolKind.NamedType => ((INamedTypeSymbol)symbol).Arity, 352SymbolKind.Method => ((IMethodSymbol)symbol).Arity, 589if (symbol.Kind != SymbolKind.Local) 775public static bool IsKind<TSymbol>(this ISymbol symbol, SymbolKind kind, [NotNullWhen(true)] out TSymbol? result) where TSymbol : class, ISymbol

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

604case SymbolKind.NamedType: 615case SymbolKind.TypeParameter:

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)

757&& symbol.IsKind(SymbolKind.Method) 1036if (receiverType.IsKind(SymbolKind.TypeParameter) && !receiverType.IsReferenceType) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1057receiverSymbol.IsKind(SymbolKind.Property); 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\SignatureComparer.cs (6)

42SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 43SymbolKind.Property => HaveSameSignature((IPropertySymbol)symbol1, (IPropertySymbol)symbol2, caseSensitive), 44SymbolKind.Event => HaveSameSignature((IEventSymbol)symbol1, (IEventSymbol)symbol2, caseSensitive), 160case SymbolKind.Method: 165case SymbolKind.Property: 172case SymbolKind.Event:

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

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

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

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

Microsoft.CodeAnalysis.CodeStyle.Fixes (68)

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

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

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

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

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

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

138.Where(m => m.Kind != SymbolKind.Method); 309CheckSurroundingContext(SymbolKind.Field, cancellationToken); 310CheckSurroundingContext(SymbolKind.Property, cancellationToken); 316SymbolKind symbolKind, CancellationToken cancellationToken) 347if (symbolKind == SymbolKind.Field) 361SymbolKind symbolKind,

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

240SymbolKind.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)

79public override SymbolKind Kind => SymbolKind.Method;

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

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

44public override SymbolKind Kind => SymbolKind.Event;

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

49public override SymbolKind Kind => SymbolKind.Field;

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

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

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

56public override SymbolKind Kind => SymbolKind.Property;

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

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

33s.Kind is SymbolKind.Local or 34SymbolKind.Parameter or 35SymbolKind.RangeVariable or 36SymbolKind.Field or 37SymbolKind.Property || 38s 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)

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

Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (15)

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

Microsoft.CodeAnalysis.CSharp (1291)

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)

290Debug.Assert(symbol.Kind != SymbolKind.Method); 291treatAsInstanceMemberAccess = !(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)

1454if (containing.Kind == SymbolKind.Method) 1461else if (containing.Kind == SymbolKind.Field) 1657&& symbol.Kind != SymbolKind.Event 1932Debug.Assert(member.Kind != SymbolKind.Property); 1933Debug.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)

156case SymbolKind.Field: 169case SymbolKind.Method:

Binder\Binder_Constraints.cs (2)

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

Binder\Binder_Crefs.cs (11)

51if (result.Kind == SymbolKind.ErrorType) 101if ((object?)containerOpt != null && containerOpt.Kind == SymbolKind.TypeParameter) 303symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 644if (s.Kind != SymbolKind.Method) 667s.Kind != SymbolKind.Method || ((MethodSymbol)s).Arity == 0); 703if (symbol.Kind == SymbolKind.TypeParameter) 718else if (symbol.Kind == SymbolKind.TypeParameter) 773case SymbolKind.Method: 803case SymbolKind.Property: 819case SymbolKind.NamedType: 915if (symbol.Kind == SymbolKind.Method)

Binder\Binder_Expressions.cs (61)

Binder\Binder_Invocation.cs (2)

370else if (boundExpression.Type?.Kind == SymbolKind.FunctionPointerType) 2093if (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)

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

Binder\Binder_Patterns.cs (6)

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

Binder\Binder_Statements.cs (4)

1849if (destinationType.Kind == SymbolKind.ArrayType) 2961return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningTask(this.Compilation); 2967return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningGenericTask(this.Compilation); 2973if (symbol?.Kind == SymbolKind.Method)

Binder\Binder_Symbols.cs (40)

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)

952if (collectionExprType.Kind == SymbolKind.DynamicType && isAsync) 959if (collectionExprType.Kind == SymbolKind.ArrayType || collectionExprType.Kind == SymbolKind.DynamicType) 1407if (member.Kind != SymbolKind.Method) 1696if (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)

138Debug.Assert(containingMemberOrLambda.Kind != SymbolKind.Local && containingMemberOrLambda.Kind != SymbolKind.RangeVariable && containingMemberOrLambda.Kind != SymbolKind.Parameter); 297=> 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)

724if (target.Type.Kind != SymbolKind.NamedType) 920if (formalType.Type.Kind != SymbolKind.NamedType)

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

1461case SymbolKind.Method: 1463case SymbolKind.Property: 3362if (targetType.Kind != SymbolKind.NamedType) 4798case SymbolKind.Property: 4800case 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: 193case SymbolKind.Namespace: 197case SymbolKind.Method: 207case 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)

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

2406within0.Kind == SymbolKind.Assembly ? 3078if (symbol.Kind == SymbolKind.Method && symbol.IsImplicitlyDeclared && ((MethodSymbol)symbol).MethodKind == MethodKind.Constructor) 3632Debug.Assert(symbol.ContainingSymbol.Kind == SymbolKind.Namespace); // avoid unnecessary traversal of nested types 4763case SymbolKind.Parameter: 4764case SymbolKind.TypeParameter: 4765case SymbolKind.Property: 4766case 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) 2468case SymbolKind.Namespace: 2473case SymbolKind.Method: 2478case SymbolKind.NamedType: 2493case SymbolKind.Method: 2514case SymbolKind.NamedType: 2529case SymbolKind.Method: 2542case SymbolKind.NamedType: 2563case ParameterSyntax param when declaredSymbol.Kind == SymbolKind.Property && param.Parent?.Parent is RecordDeclarationSyntax recordDeclaration && recordDeclaration.ParameterList == param.Parent: 2575case SymbolKind.Method: 2599case 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)

508case SymbolKind.NamedType: 512case SymbolKind.Method: 553case SymbolKind.Property: 563case 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)

325if (member.Kind == SymbolKind.Method) 949if (m.Kind == SymbolKind.Event) 1028if (m.Kind == SymbolKind.Method) 1045if (m.Kind == SymbolKind.Property)

Emitter\Model\PEAssemblyBuilder.cs (1)

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

Emitter\Model\PEModuleBuilder.cs (25)

Emitter\Model\SymbolAdapter.cs (5)

68(this.Kind == SymbolKind.Assembly && this is SourceAssemblySymbol) || 69(this.Kind == SymbolKind.NetModule && this is SourceModuleSymbol)); 88Debug.Assert(this.Kind != SymbolKind.Assembly); 95Debug.Assert(this.Kind != SymbolKind.Assembly); 151if (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)

301case SymbolKind.Field: 304case SymbolKind.Method: 307case SymbolKind.Property: 310case SymbolKind.Event:

Emitter\NoPia\EmbeddedTypesManager.cs (3)

272if (member.Kind != SymbolKind.NamedType) 514case SymbolKind.Property: 517case SymbolKind.Event:

Errors\MessageProvider.cs (2)

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

FlowAnalysis\AbstractFlowPass.cs (1)

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

288Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event, 509bool hasAssociatedProperty = associatedPropertyOrEvent?.Kind == SymbolKind.Property; 707Debug.Assert(captured.Kind == SymbolKind.Parameter || captured.Kind == SymbolKind.Local || captured.Kind == SymbolKind.RangeVariable); 743else if (variable.Kind != SymbolKind.RangeVariable) 787if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 869if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 1231symbol.Kind == SymbolKind.Local && 1244if (symbol.Kind == SymbolKind.Field) 1248else if (symbol.Kind == SymbolKind.Parameter && 1324var hasAssociatedProperty = associatedSymbol?.Kind == SymbolKind.Property; 1822while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property) 2683if (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)

195case SymbolKind.Field: 207case SymbolKind.Event: 254for (; 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)

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

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (2)

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

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

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

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

578case SymbolKind.Parameter: 579case SymbolKind.Local: 586case 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)

752case SymbolKind.Parameter: 763case 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)

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

Lowering\LocalRewriter\LocalRewriter_Call.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (5)

176Debug.Assert(propertyOrEvent.Kind == SymbolKind.Property || propertyOrEvent.Kind == SymbolKind.Event); 216var variableRepresentsLocation = rewrittenReceiver.Type.IsValueType || rewrittenReceiver.Type.Kind == SymbolKind.TypeParameter; 474Debug.Assert(fieldOrEvent.Kind == SymbolKind.Field || fieldOrEvent.Kind == SymbolKind.Event);

Lowering\LocalRewriter\LocalRewriter_ForEachStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_LockStatement.cs (1)

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

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (3)

707case SymbolKind.Field: 711case SymbolKind.Property: 740case SymbolKind.Event:

Lowering\MethodToClassRewriter.cs (3)

406if (member.Kind == SymbolKind.Property) 433case SymbolKind.Field: 436case SymbolKind.Property:

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (8)

161case SymbolKind.Local: 168case SymbolKind.Parameter: 172case SymbolKind.Field: 211var type = (variable.Kind == SymbolKind.Local) ? ((LocalSymbol)variable).Type : ((ParameterSymbol)variable).Type; 262case SymbolKind.Field: 264goto case SymbolKind.Local; 266case SymbolKind.Local: 267case SymbolKind.Parameter:

Lowering\StateMachineRewriter\MethodToStateMachineRewriter.cs (2)

177Debug.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)

53while (underlyingType.Kind == SymbolKind.ArrayType && !ShouldAddNullableAnnotation(underlyingType)); 821if (owner.Kind == SymbolKind.Method) 848if (typeArg.Kind == SymbolKind.TypeParameter) 886if (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)

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

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

119case SymbolKind.Field:

Symbols\ArrayTypeSymbol.cs (2)

288public override SymbolKind Kind 292return SymbolKind.ArrayType;

Symbols\AssemblySymbol.cs (2)

196public sealed override SymbolKind Kind 200return 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)

587if (type.Kind == SymbolKind.NamedType) 591else if (type.Kind == SymbolKind.PointerType)

Symbols\DiscardSymbol.cs (2)

31public override SymbolKind Kind => SymbolKind.Discard;

Symbols\DynamicTypeSymbol.cs (2)

54public override SymbolKind Kind 58return SymbolKind.DynamicType;

Symbols\ErrorTypeSymbol.cs (2)

219public sealed override SymbolKind Kind 223return SymbolKind.ErrorType;

Symbols\EventSymbol.cs (2)

238public sealed override SymbolKind Kind 242return 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)

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

553if (member.Kind != SymbolKind.Field) 868case SymbolKind.Method: 870case SymbolKind.Property: //NOTE: Not using PropertySymbol.CallingConvention 871case SymbolKind.Event: 880return member.Kind == SymbolKind.Method && ((MethodSymbol)member).IsVararg;

Symbols\MemberSymbolExtensions.cs (72)

Symbols\MergedNamespaceSymbol.cs (1)

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

550while (s.Kind != SymbolKind.Namespace) 1160if (staticIndex < staticFields.Length && staticFields[staticIndex].Kind == SymbolKind.Field) 1176Debug.Assert(staticIndex == staticFields.Length || staticFields[staticIndex].Kind != SymbolKind.Field); 1188IEnumerable<FieldSymbol> nonEventFields = GetMembers<FieldSymbol>(this.GetMembers().WhereAsArray(m => !(m is TupleErrorFieldSymbol)), SymbolKind.Field, offset: 0); 1261int index = GetIndexOfFirstMember(members, SymbolKind.Method); 1267if (members[index].Kind != SymbolKind.Method) 1285if (index >= members.Length || members[index].Kind != SymbolKind.Method) 1313if (index == members.Length || members[index].Kind != SymbolKind.Method) 1353return GetMembers<PropertySymbol>(this.GetMembers(), SymbolKind.Property); 1358return GetMembers<EventSymbol>(this.GetMembers(), SymbolKind.Event); 1475Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder()); 1476Debug.Assert(SymbolKind.Method.ToSortOrder() < SymbolKind.Property.ToSortOrder()); 1477Debug.Assert(SymbolKind.Property.ToSortOrder() < SymbolKind.Event.ToSortOrder()); 1478Debug.Assert(SymbolKind.Event.ToSortOrder() < SymbolKind.NamedType.ToSortOrder()); 1574Debug.Assert(field.AssociatedSymbol.Kind == SymbolKind.Event); 1646if (member.Kind == SymbolKind.NamedType) 2697private static int GetIndexOfFirstMember(ImmutableArray<Symbol> members, SymbolKind kind) 2714private 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)

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

Symbols\MethodSymbolExtensions.cs (7)

95public static bool CanBeHiddenByMemberKind(this MethodSymbol hiddenMethod, SymbolKind hidingMemberKind) 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)

315if (candidate.Kind == SymbolKind.Property) 350if (member.Kind == SymbolKind.Method) 714case SymbolKind.Field: 715case SymbolKind.Event: 769public override SymbolKind Kind // Cannot seal this method because of the ErrorSymbol. 773return SymbolKind.NamedType; 1650ContainingSymbol?.Kind == SymbolKind.Namespace &&

Symbols\NamespaceOrTypeSymbol.cs (2)

43return Kind == SymbolKind.Namespace; 262if (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 (33)

Symbols\ParameterSymbol.cs (2)

260public sealed override SymbolKind Kind 264return SymbolKind.Parameter;

Symbols\PointerTypeSymbol.cs (2)

159public override SymbolKind Kind 163return 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)

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

Symbols\Source\ParameterHelpers.cs (1)

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

Symbols\Source\SourceAssemblySymbol.cs (5)

1113if (member.Kind == SymbolKind.Namespace) 2075case SymbolKind.Namespace: 2081case SymbolKind.NamedType: 2237if (forwardedType.Kind != SymbolKind.NamedType) 2732if ((object)associatedPropertyOrEvent != null && associatedPropertyOrEvent.Kind == SymbolKind.Event)

Symbols\Source\SourceEventSymbol.cs (1)

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

Symbols\Source\SourceMemberContainerSymbol.cs (30)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (33)

Symbols\Source\SourceMemberFieldSymbol.cs (1)

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

Symbols\Source\SourceModuleSymbol.cs (4)

171case SymbolKind.Namespace: 179case SymbolKind.NamedType: 610case SymbolKind.Namespace: 616case SymbolKind.NamedType:

Symbols\Source\SourceNamedTypeSymbol.cs (1)

93if (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 TypeSymbol { IsExtension: true });

Symbols\SubstitutedNamedTypeSymbol.cs (3)

140public sealed override SymbolKind Kind 251if (t.Kind == SymbolKind.NamedType) 301if (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: 911Debug.Assert(this.Kind == SymbolKind.Method); 930case SymbolKind.Assembly: 931case SymbolKind.NamedType: 932case SymbolKind.Method:

Symbols\SymbolDistinguisher.cs (26)

59case SymbolKind.ErrorType: 60case SymbolKind.NamedType: 61case SymbolKind.Event: 62case SymbolKind.Field: 63case SymbolKind.Method: 64case SymbolKind.Property: 65case SymbolKind.TypeParameter: 67case SymbolKind.ArrayType: 68case SymbolKind.PointerType: 69case SymbolKind.Parameter: 71case SymbolKind.DynamicType: // Can't sensibly append location, but it should never be ambiguous. 72case SymbolKind.FunctionPointerType: // Can't sensibly append location 74case SymbolKind.Namespace: 75case SymbolKind.Alias: 76case SymbolKind.Assembly: 77case SymbolKind.NetModule: 78case SymbolKind.Label: 79case SymbolKind.Local: 80case SymbolKind.RangeVariable: 81case SymbolKind.Preprocessing: 146case SymbolKind.Parameter: 149case SymbolKind.PointerType: 152case SymbolKind.ArrayType: 196Debug.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)

55if (ContainingSymbol.Kind == SymbolKind.NamedType && ContainingSymbol.IsImplicitlyDeclared) 128case SymbolKind.Field:

Symbols\Synthesized\SynthesizedSubstitutedTypeParameterSymbol.cs (1)

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

Symbols\Tuples\TupleTypeSymbol.cs (11)

595case SymbolKind.Field: 691case SymbolKind.NamedType: 692case SymbolKind.Method: 693case SymbolKind.Property: 694case SymbolKind.Event: 1016if (member.Kind != SymbolKind.Field) 1063case SymbolKind.Method: 1064case SymbolKind.Property: 1065case SymbolKind.NamedType: 1069case SymbolKind.Field: 1077case SymbolKind.Event:

Symbols\TypeParameterSymbol.cs (2)

187public sealed override SymbolKind Kind 191return SymbolKind.TypeParameter;

Symbols\TypeSymbol.cs (25)

Symbols\TypeSymbolExtensions.cs (19)

267if (type.Kind == SymbolKind.ArrayType) 329return type.Kind == SymbolKind.NamedType && ((NamedTypeSymbol)type).IsInterface; 347return type.Kind == SymbolKind.ErrorType; 352return p.ContainingSymbol.Kind == SymbolKind.Method; 553if (symbol.Kind != SymbolKind.Namespace) 1011for (Symbol s2 = sym2; s2.Kind != SymbolKind.Namespace; s2 = s2.ContainingSymbol) 1746case SymbolKind.Method: 1747case SymbolKind.NamedType: 1748case SymbolKind.ErrorType: 1749case SymbolKind.Field: 1750case SymbolKind.Property: 1751case SymbolKind.Event: 1778if (container.Kind != SymbolKind.Namespace) 1919case SymbolKind.NamedType: 1920case SymbolKind.ErrorType: 1927case SymbolKind.ArrayType: 1934case SymbolKind.PointerType: 1941case SymbolKind.FunctionPointerType: 2276if (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: 303case SymbolKind.TypeParameter: 330case SymbolKind.ArrayType: 333case SymbolKind.ErrorType: 334case 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)

52}, 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)

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

1127return typeInfo.Type?.Kind == SymbolKind.ArrayType; 1135if (symbol?.Kind == SymbolKind.Field)

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

107if (conflict?.IsKind(SymbolKind.NamedType) == true) 285if (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)

80var members = GetMembers(namedType).Where(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)

1013if (conditionOrType.GetBestOrAllSymbols().FirstOrDefault() is { Kind: SymbolKind.NamedType }) 3058case SymbolKind.NamedType: 3060case 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)

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

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

634if (method.TypeArguments.Any(static t => t.Kind == SymbolKind.ErrorType)) 675if (returnType.Kind == SymbolKind.TypeParameter) 677if (inferredType.Kind != SymbolKind.TypeParameter) 696case SymbolKind.ArrayType: 699case SymbolKind.PointerType: 702case SymbolKind.NamedType: 1825SemanticModel.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)

16005SymbolKind.NamedType); 16022SymbolKind.NamedType);

Microsoft.CodeAnalysis.CSharp.EditorFeatures (1)

EventHookup\EventHookupCommandHandler_TabKeyCommand.cs (1)

322if (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 100Assert.True(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 101Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 113Assert.True(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.NamedType)); 114Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.SymbolKind == SymbolKind.Property)); 858=> 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)

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

4078Assert.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)

4259ParentKind = SymbolKind.Assembly, 4328ParentKind = SymbolKind.Assembly, 4378ParentKind = SymbolKind.Assembly, 4439ParentKind = SymbolKind.Assembly, 4456ParentKind = SymbolKind.Assembly, 4502ParentKind = SymbolKind.Assembly, 4559ParentKind = SymbolKind.Assembly, 4576ParentKind = SymbolKind.Assembly,

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

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

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

82Assert.Equal(SymbolKind.NamedType, symbol.Kind); 25511Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 25560Assert.Equal(SymbolKind.Parameter, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 26591Assert.Equal(SymbolKind.Parameter, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 26624Assert.Equal(SymbolKind.NamedType, model.GetSymbolInfo(memberAccess.Expression).Symbol.Kind); 28140Assert.Equal(SymbolKind.Parameter, symbol.Kind);

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)

195Assert.NotEqual(SymbolKind.Field, symbol.Kind); 205if (symbol.Kind == SymbolKind.Local) 246Assert.Equal(SymbolKind.Field, symbol.Kind); 400Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind); 401Assert.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 (85)

AddImport\CSharpAddImportFeatureService.cs (2)

336return namespaceOrTypeSymbol.IsKind(SymbolKind.Namespace) 488usingDirective = namespaceOrTypeSymbol.IsKind(SymbolKind.Namespace)

ChangeSignature\CSharpChangeSignatureService.cs (1)

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

CodeRefactorings\ConvertLocalFunctionToMethod\CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs (1)

287containingSymbol.Kind != SymbolKind.NamedType)

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (2)

524Kind: SymbolKind.Property or SymbolKind.Field,

Completion\CompletionProviders\CompletionUtilities.cs (1)

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

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

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

48if (nameInfo.PossibleSymbolKinds.Any(static k => k.SymbolKind == SymbolKind.Parameter)) 309result.Add((overloadParameter.Name, NameDeclarationInfo.GetGlyph(SymbolKind.Parameter, declarationInfo.DeclaredAccessibility))); 334return symbol.Kind is SymbolKind.Local or 335SymbolKind.Parameter or 336SymbolKind.RangeVariable;

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

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

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

141member.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)

86new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

Debugging\CSharpProximityExpressionsService.cs (1)

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

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (1)

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

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

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

254if (symbol is IMethodSymbol method && method.ContainingSymbol.IsKind(SymbolKind.Method))

NavigationBar\CSharpNavigationBarItemService.cs (3)

74member.Kind == SymbolKind.NamedType || 174if (member.Kind == SymbolKind.Method) 204if (symbol.Kind == SymbolKind.Field)

Rename\CSharpRenameIssuesService.cs (1)

28symbol.Kind == SymbolKind.DynamicType)

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

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

52}, 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)

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

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

Diagnostics\Suppression\RemoveUnnecessaryPragmaSuppressionsTests.cs (1)

1312}, 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)

71784Assert.Equal(SymbolKind.Discard, discard1.Kind); 71788Assert.Equal(SymbolKind.Discard, discard2.Kind); 71792Assert.Equal(SymbolKind.Discard, discard3.Kind); 71796Assert.Equal(SymbolKind.Discard, discard4.Kind); 71800Assert.Equal(SymbolKind.Discard, discard5.Kind);

Semantics\OperatorTests.cs (1)

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

Semantics\QueryTests.cs (18)

Semantics\RecordStructTests.cs (21)

Semantics\RefFieldTests.cs (1)

2020var 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 (954)

Compilation\CompilationAPITests.cs (1)

1198Assert.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 (300)

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)

2142Assert.Equal(SymbolKind.Method, symbol.Kind); 2176Assert.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)

140var typeAProperties = type.GetMembers().Where(m => m.Kind == SymbolKind.Property).Cast<PropertySymbol>().ToArray(); 1232var classCIndexer = classC.GetMembers().Where(s => s.Kind == SymbolKind.Property).Single(); 1244var 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)

169var outerInterfaceProperty = outerInterface.GetMembers().Single(m => m.Kind == SymbolKind.Property); 179var 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); 687Assert.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)

41Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 43Assert.Equal(SymbolKind.Parameter, x.Kind); 123Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 125Assert.Equal(SymbolKind.Parameter, x.Kind); 147Assert.Equal(SymbolKind.NamedType, x.Type.Kind); 149Assert.Equal(SymbolKind.Parameter, x.Kind); 448Assert.Equal(SymbolKind.Method, method.Kind);

Symbols\Source\PropertyTests.cs (2)

401if (m.Kind == SymbolKind.Field) 420if (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)

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

Symbols\SymbolErrorTests.cs (3)

16894Assert.Equal(SymbolKind.ErrorType, fieldType.Type.Kind); 16921Assert.Equal(SymbolKind.ErrorType, fieldType.Kind); 16958Assert.Equal(SymbolKind.ErrorType, fieldType.Kind);

Symbols\TypeTests.cs (24)

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

Syntax\FieldAndValueKeywordTests.cs (1)

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

679if (leftHandBinding.GetBestOrAllSymbols().FirstOrDefault().MatchesKind(SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Alias)) 776symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace or SymbolKind.Alias) 782if (symbol.Kind is SymbolKind.Method && 798if (symbol.Kind is SymbolKind.NamedType or SymbolKind.Namespace or SymbolKind.TypeParameter)

Rename\CSharpRenameRewriterLanguageService.cs (17)

539if (symbol != null && _renamedSymbol.Kind != SymbolKind.Local && _renamedSymbol.Kind != SymbolKind.RangeVariable && 757.Where(s => s.MatchesKind(SymbolKind.Local, SymbolKind.Parameter) && s.Name == token.ValueText); 766(matchingLocal.IsKind(SymbolKind.Local) && ((ILocalSymbol)matchingLocal).Type.IsDelegateType()) || 767(matchingLocal.IsKind(SymbolKind.Parameter) && ((IParameterSymbol)matchingLocal).Type.IsDelegateType()); 804if (renamedSymbol.Kind is SymbolKind.Parameter or 805SymbolKind.Local or 806SymbolKind.RangeVariable) 830else if (renamedSymbol.Kind == SymbolKind.Label) 839else if (renamedSymbol.Kind == SymbolKind.Method) 857else if (renamedSymbol.Kind == SymbolKind.Alias) 889else if (renamedSymbol.Kind == SymbolKind.TypeParameter) 978var implicitReferencesMightConflict = renameSymbol.Kind == SymbolKind.Property && 983(renameSymbol.Kind == SymbolKind.Method && 1048if (symbol.Kind == SymbolKind.Method) 1099if (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)

1127return typeInfo.Type?.Kind == SymbolKind.ArrayType; 1135if (symbol?.Kind == SymbolKind.Field)

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

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

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

80var members = GetMembers(namedType).Where(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)

1013if (conditionOrType.GetBestOrAllSymbols().FirstOrDefault() is { Kind: SymbolKind.NamedType }) 3058case SymbolKind.NamedType: 3060case 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)

46visibleSymbols = 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)

1034var property = typeC.GetMembers().First(m => m.Kind == SymbolKind.Property); 1044var iproperty = typeI.GetMembers().First(m => m.Kind == SymbolKind.Property);

Microsoft.CodeAnalysis.EditorFeatures (1)

InlineRename\AbstractEditorInlineRenameService.SymbolRenameInfo.cs (1)

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

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

CodeFixes\CodeFixServiceTests.cs (1)

1201}, SymbolKind.NamedType);

Diagnostics\DiagnosticAnalyzerServiceTests.cs (1)

927}, SymbolKind.NamedType);

Microsoft.CodeAnalysis.EditorFeatures.Wpf (6)

Peek\PeekHelpers.cs (6)

57case SymbolKind.Event: 58case SymbolKind.Field: 59case SymbolKind.Method: 60case SymbolKind.Property: 64case SymbolKind.NamedType: 65case SymbolKind.Namespace:

Microsoft.CodeAnalysis.EditorFeatures2.UnitTests (18)

CodeFixes\CodeFixServiceTests.vb (1)

201context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType)

Diagnostics\AdditionalFileDiagnosticsTests.vb (1)

77context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType)

Diagnostics\DiagnosticServiceTests.vb (12)

1256context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.Method) 1465End Sub, SymbolKind.NamedType) 1546context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType) 1571context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType) 1606End Sub, SymbolKind.NamedType) 1623context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType) 1647Private Shared ReadOnly Property SymbolKindsOfInterest As SymbolKind() 1747context.RegisterSymbolAction(Sub(s) Return, SymbolKind.NamedType) 1779context.RegisterSymbolAction(AddressOf compilationAnalyzer.AnalyzeSymbol, SymbolKind.NamedType) 1890End Sub, SymbolKind.Method) 2457Assert.Equal(SymbolKind.Method, analyzedMethod.Kind) 2521context.RegisterSymbolAction(Sub(symbolContext) AnalyzedMethodSymbols.Add(symbolContext.Symbol), SymbolKind.Method)

FindReferences\FindReferencesTests.LinkedFiles.vb (3)

73references = references.Where(Function(r) r.Definition.IsKind(SymbolKind.NamedType)) 115references = references.Where(Function(r) r.Definition.IsKind(SymbolKind.NamedType)) 129references = references.Where(Function(r) r.Definition.IsKind(SymbolKind.NamedType))

FindReferences\FindReferencesTests.vb (1)

460referencedSymbol.Definition.Kind = SymbolKind.Namespace

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)

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

Microsoft.CodeAnalysis.Features (249)

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)

226if (suppressionTargetInfo.TargetMemberNode != null && suppressionTargetInfo.TargetSymbol.Kind != SymbolKind.Namespace) 353protected static string GetScopeString(SymbolKind targetSymbolKind) 357case SymbolKind.Event: 358case SymbolKind.Field: 359case SymbolKind.Method: 360case SymbolKind.Property: 363case SymbolKind.NamedType: 366case SymbolKind.Namespace:

CodeLens\CodeLensFindReferenceProgress.cs (1)

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

CodeLens\CodeLensReferencesService.cs (1)

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

96fieldOrProperty.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)

387using var _ = PooledHashSet<(string Name, SymbolKind Kind)>.GetInstance(out var symbolNameAndKindSet);

Completion\Providers\SymbolCompletionItem.cs (2)

383internal static SymbolKind? GetKind(CompletionItem item) 384=> item.TryGetProperty("SymbolKind", out var kind) ? (SymbolKind?)int.Parse(kind) : null;

ConvertTupleToStruct\AbstractConvertTupleToStructCodeRefactoringProvider.cs (1)

294var 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 (13)

316SymbolKind.Event => GetDisplayName((IEventSymbol)symbol), 317SymbolKind.Field => GetDisplayName((IFieldSymbol)symbol), 318SymbolKind.Method => GetDisplayName((IMethodSymbol)symbol), 319SymbolKind.NamedType => GetDisplayName((INamedTypeSymbol)symbol), 320SymbolKind.Parameter => FeaturesResources.parameter, 321SymbolKind.Local => FeaturesResources.local_variable, 322SymbolKind.Property => GetDisplayName((IPropertySymbol)symbol), 323SymbolKind.TypeParameter => FeaturesResources.type_parameter, 2462case SymbolKind.Field: 2465case SymbolKind.Event: 2468case SymbolKind.Property: 2474case SymbolKind.Method: 2481case SymbolKind.NamedType when oldMember is INamedTypeSymbol { DelegateInvokeMethod: { } oldInvokeMethod }:

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)

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

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

579if (declaredSymbol.IsKind(SymbolKind.Property) 580|| declaredSymbol.IsKind(SymbolKind.Method) 581|| 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)

83if (symbol.Kind == SymbolKind.Namespace) 288case SymbolKind.Event: 289case SymbolKind.Field: 290case SymbolKind.Method: 291case SymbolKind.NamedType: 292case SymbolKind.Property: 293case 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)

47_ => member.IsKind(SymbolKind.Property) || member.IsKind(SymbolKind.Event) || member.IsKind(SymbolKind.Field),

PullMemberUp\MembersPuller.cs (1)

287if (memberResult.MakeMemberDeclarationAbstract && !memberResult.Member.IsKind(SymbolKind.Field))

QuickInfo\CommonSemanticQuickInfoProvider.cs (2)

173s1.Kind == SymbolKind.NamedType ? -1 : 174s2.Kind == SymbolKind.NamedType ? 1 : 0)];

Rename\SymbolicRenameInfo.cs (7)

166if (symbol.Kind == SymbolKind.Alias && symbol.IsExtern) 170if (symbol.Kind == SymbolKind.NamedType && 187symbol.Kind != SymbolKind.Local && 188!(symbol.Kind == SymbolKind.Parameter && 189symbol.ContainingSymbol.Kind == SymbolKind.Method && 200if (symbol.Kind == SymbolKind.Property && symbol.ContainingType.IsAnonymousType) 206if (symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).MethodKind == MethodKind.UserDefinedOperator)

SemanticSearch\QueryExecutionContext.cs (8)

90if (kind == SymbolKind.NamedType) 205private static SymbolKind GetSymbolKind(QueryKind targetEntity) 208QueryKind.Field => SymbolKind.Field, 209QueryKind.Method => SymbolKind.Method, 210QueryKind.Property => SymbolKind.Property, 211QueryKind.Event => SymbolKind.Event, 212QueryKind.NamedType => SymbolKind.NamedType, 213QueryKind.Namespace => SymbolKind.Namespace,

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)

64var 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\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (5)

768case SymbolKind.NamedType: 769case SymbolKind.Method: 770case SymbolKind.Field: 771case SymbolKind.Property: 772case 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)

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

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

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

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

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

240SymbolKind.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 == SymbolKind.Namespace)

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (2)

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (2)

114([SymbolKind.Property], Capitalization.AllUpper, ReportDiagnostic.Error)); 160([MethodKind.Ordinary, SymbolKind.Field], Capitalization.PascalCase, ReportDiagnostic.Error));

Microsoft.CodeAnalysis.PublicApiAnalyzers (45)

DeclarePublicApiAnalyzer.cs (5)

145SymbolKind.NamedType, 146SymbolKind.Event, 147SymbolKind.Field, 148SymbolKind.Method); 151SymbolKind.Property);

DeclarePublicApiAnalyzer.Impl.cs (2)

301if (symbol.Kind == SymbolKind.Method) 584if (symbol.Kind == SymbolKind.NamedType)

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

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

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

Microsoft.CodeAnalysis.ResxSourceGenerator (85)

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)

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

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

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

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

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

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

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

Microsoft.CodeAnalysis.Test.Utilities (81)

Compilation\CompilationDifference.cs (1)

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

235if (declaration.DeclaredSymbol.Kind == SymbolKind.Method && compilation.Language == LanguageNames.VisualBasic) 257case SymbolKind.Field: 258case SymbolKind.Event: 259case SymbolKind.Method: 260case SymbolKind.NamedType: 261case 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)

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

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

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

137If symbol.Kind = SymbolKind.Method AndAlso symbol.IsImplicitlyDeclared AndAlso 390If symbol.Kind = SymbolKind.NamedType Then 397If symbol.Kind = SymbolKind.Method Then 469Debug.Assert(fieldOrProperty.Kind = SymbolKind.Field) 656Case SymbolKind.NamedType 659Case SymbolKind.Method 760If member.IsShared OrElse Not member.IsFromCompilation(_compilation) OrElse member.Kind <> SymbolKind.Method Then 864If 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)

1567If (Not lookupResult.IsGoodOrAmbiguous) OrElse lookupResult.Symbols(0).Kind <> SymbolKind.Method Then 2022Return 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)

151If type.Kind = SymbolKind.ErrorType Then

Emit\EditAndContinue\PEDeltaAssemblyBuilder.vb (2)

178If member.Kind <> SymbolKind.Property Then 204Debug.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)

225Case SymbolKind.NetModule 228Case SymbolKind.Namespace 287Case SymbolKind.Namespace 302Case SymbolKind.NamedType 330Case SymbolKind.NamedType, 331SymbolKind.ErrorType 334Case SymbolKind.Method 490Case SymbolKind.ArrayType 493Case SymbolKind.NamedType, 494SymbolKind.ErrorType 497Case SymbolKind.TypeParameter 508If symbol.Kind = SymbolKind.NamedType Then

Emit\NamedTypeSymbolAdapter.vb (5)

282If member.Kind = SymbolKind.Method Then 476If member.Kind = SymbolKind.Method Then 908If member.Kind = SymbolKind.Event Then 980If member.Kind = SymbolKind.Method Then 997If member.Kind = SymbolKind.Property Then

Emit\NoPia\EmbeddedEvent.vb (1)

113If m.Kind = SymbolKind.Method Then

Emit\NoPia\EmbeddedType.vb (4)

236Case SymbolKind.Field 238Case SymbolKind.Method 240Case SymbolKind.Property 242Case SymbolKind.Event

Emit\NoPia\EmbeddedTypesManager.vb (3)

224If member.Kind <> SymbolKind.NamedType Then 431Case SymbolKind.Property 433Case 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 364If sym.Kind = SymbolKind.NamedType Then 373Debug.Assert(sym.Kind = SymbolKind.Namespace) 504If symbol.Kind = SymbolKind.NamedType Then 660Case SymbolKind.Namespace 668Case SymbolKind.Namespace, SymbolKind.NamedType 676Case SymbolKind.NamedType

Emit\SymbolAdapter.vb (2)

80Debug.Assert(Me.Kind <> SymbolKind.Assembly) 120If Me.Kind = SymbolKind.Assembly Then

Emit\SymbolTranslator.vb (7)

133If namedTypeSymbol.OriginalDefinition.Kind = SymbolKind.ErrorType Then 137If diagInfo Is Nothing AndAlso namedTypeSymbol.Kind = SymbolKind.ErrorType Then 254Case SymbolKind.ArrayType 256Case SymbolKind.NamedType, SymbolKind.ErrorType 258Case SymbolKind.TypeParameter 461Return 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)

256local.ContainingSymbol.Kind <> SymbolKind.Method, 409If 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)

3253If candidateSymbol.Kind = SymbolKind.Method Then 3279Dim candidateIsAProperty As Boolean = (candidate.Candidate.UnderlyingSymbol.Kind = SymbolKind.Property) 3294If targetType.Kind <> SymbolKind.ArrayType Then 3384If targetType.Kind = SymbolKind.ErrorType Then 3459If targetType.Kind = SymbolKind.ErrorType Then 4945If leftType.Kind = SymbolKind.NamedType AndAlso rightType.Kind = SymbolKind.NamedType Then 5081If symbol.ContainingSymbol.Kind = SymbolKind.NamedType Then 5107Case SymbolKind.TypeParameter 5111Case SymbolKind.ArrayType 5116Case SymbolKind.NamedType, SymbolKind.ErrorType 5207paramType.Kind = SymbolKind.ArrayType Then 5222If paramForGenericityCheck.ContainingSymbol.Kind = SymbolKind.Method Then 5234paramType.Kind = SymbolKind.ArrayType Then

Semantics\TypeInference\TypeArgumentInference.vb (19)

929If targetType.Kind <> SymbolKind.ArrayType Then 971If targetType.Kind = SymbolKind.ErrorType Then 1069Case SymbolKind.TypeParameter 1089Case SymbolKind.ArrayType 1093Case SymbolKind.NamedType 1296Case SymbolKind.TypeParameter 1311Case SymbolKind.ArrayType 1315Case SymbolKind.NamedType 1425ElseIf parameterType.Kind = SymbolKind.NamedType Then 1432Dim argumentTypeAsNamedType = If(argumentType.Kind = SymbolKind.NamedType, DirectCast(argumentType.GetTupleUnderlyingTypeOrSelf(), NamedTypeSymbol), Nothing) 1772Dim fixedTypeAsNamedType = If(fixedType.Kind = SymbolKind.NamedType, DirectCast(fixedType, NamedTypeSymbol), Nothing) 1788Dim baseSearchTypeKind As SymbolKind = baseSearchType.Kind 1790If baseSearchTypeKind <> SymbolKind.NamedType AndAlso baseSearchTypeKind <> SymbolKind.TypeParameter AndAlso 1791Not (baseSearchTypeKind = SymbolKind.ArrayType AndAlso DirectCast(baseSearchType, ArrayTypeSymbol).IsSZArray) Then 1841Case SymbolKind.TypeParameter 1873Case SymbolKind.TypeParameter 2172lambdaReturnType IsNot Nothing AndAlso lambdaReturnType.Kind = SymbolKind.NamedType AndAlso 2173returnType 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 498If 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 704Return 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)

103Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 105Return SymbolKind.ErrorType

Symbols\EventSymbol.vb (2)

130Public NotOverridable Overrides ReadOnly Property Kind As SymbolKind 132Return 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)

175While s.Kind <> SymbolKind.Namespace 391If (Not member.IsShared AndAlso member.Kind = SymbolKind.Field) Then 522Return GetMembers(Of FieldSymbol)(GetMembers(), SymbolKind.Field, offset:=0) 529Dim index = GetIndexOfFirstMember(members, SymbolKind.Method) 534If member.Kind <> SymbolKind.Method Then 550If index >= members.Length OrElse members(index).Kind <> SymbolKind.Method Then 571If index = members.Length OrElse members(index).Kind <> SymbolKind.Method Then 603Return GetMembers(Of PropertySymbol)(GetMembers(), SymbolKind.Property) 607Return GetMembers(Of EventSymbol)(GetMembers(), SymbolKind.Event) 630Case SymbolKind.Field 632Case SymbolKind.Method 640Case SymbolKind.Property 642Case SymbolKind.Event 644Case SymbolKind.NamedType 924If _container.Kind = SymbolKind.Namespace AndAlso _arity = 0 Then 1117If member.Kind = SymbolKind.Property Then 1560Private Shared Function GetIndexOfFirstMember(members As ImmutableArray(Of Symbol), kind As SymbolKind) As Integer 1574Private 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)

229(varType.Kind = SymbolKind.TypeParameter AndAlso varType.IsReferenceType)) Then

Symbols\Source\SourceMemberMethodSymbol.vb (2)

108OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Method, m_containingType) 959If symbol.Kind = SymbolKind.Property Then

Symbols\Source\SourceMethodSymbol.vb (7)

1057container.FindMember(propertyIdentifier.ValueText, SymbolKind.Property, propertyIdentifier.Span, tree), 1088container.FindMember(eventIdentifier.ValueText, SymbolKind.Event, eventIdentifier.Span, tree), 1124Return container.FindMember(propertyIdentifier.ValueText, SymbolKind.Property, propertyIdentifier.Span, tree) 1128Return container.FindMember(eventIdentifier.ValueText, SymbolKind.Event, eventIdentifier.Span, tree) 1132Return container.FindMember(delegateIdentifier.ValueText, SymbolKind.NamedType, delegateIdentifier.Span, tree) 1136SymbolKind.Method, GetMethodLocationFromSyntax(syntax), tree), MethodSymbol) 1786If 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)

81If containingSymbol.Kind = SymbolKind.Namespace AndAlso 94If containingSymbol.Kind = SymbolKind.NamedType Then 503Case SymbolKind.Namespace 510Case SymbolKind.NamedType 538If s.Kind = SymbolKind.Namespace Then 2284If ContainingSymbol.Kind = SymbolKind.Namespace AndAlso attrData.IsTargetAttribute(AttributeDescription.CaseInsensitiveExtensionAttribute) Then 2412If member.Kind = SymbolKind.Event AndAlso 2486If Not m.IsShared And m.Kind = SymbolKind.Field Then 2680If member.Kind = SymbolKind.Method Then

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (13)

102If m.Kind = SymbolKind.Method Then 375Dim memberKind As SymbolKind = member.Kind 379Case SymbolKind.Field, SymbolKind.NamedType 381Case SymbolKind.Method 393Case SymbolKind.Property 448Case SymbolKind.Event 451Case SymbolKind.Method 494If target.Kind <> SymbolKind.Property OrElse Not DirectCast(target, PropertySymbol).IsDefault Then 546Case SymbolKind.Method 565Case SymbolKind.Property 1337If attributeSource.Kind = SymbolKind.Method Then 1378If 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)

415OverloadingHelper.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)

61Case SymbolKind.Assembly 64Case SymbolKind.Event 67Case SymbolKind.Field 70Case SymbolKind.Method 91Case SymbolKind.Property 94Case SymbolKind.NamedType 119Case SymbolKind.NetModule 122Case SymbolKind.Parameter 125Case SymbolKind.TypeParameter 255Dim sourceAssembly = DirectCast(If(Me.Kind = SymbolKind.Assembly, Me, Me.ContainingAssembly), SourceAssemblySymbol) 519Debug.Assert(Me.Kind = SymbolKind.Method OrElse Me.Kind = SymbolKind.Property) 529Me.Kind = SymbolKind.Event AndAlso DirectCast(Me, SourceEventSymbol).AssociatedField IsNot Nothing Then 545If Me.Kind = SymbolKind.Method Then 587Case SymbolKind.Assembly, SymbolKind.NamedType, SymbolKind.Method

Symbols\SymbolExtensions.vb (43)

Symbols\Tuples\TupleTypeSymbol.vb (16)

144Public Overrides ReadOnly Property Kind As SymbolKind 146Return SymbolKind.NamedType 667If member.Kind <> SymbolKind.Field Then 715Case SymbolKind.Method 720Case SymbolKind.Field 789Case SymbolKind.NamedType 792Case SymbolKind.Property 797Case SymbolKind.Event 895Dim kind As SymbolKind = symbol.Kind 897Case SymbolKind.[Event] 909Case SymbolKind.Field 915Case SymbolKind.Method 918Case SymbolKind.Property 956Debug.Assert(Not GetMembers().Any(Function(m) m.Kind = SymbolKind.NamedType)) 962Debug.Assert(Not GetMembers().Any(Function(m) m.Kind = SymbolKind.NamedType)) 968Debug.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)

507If 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.VisualBasic.CodeStyle (13)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb (6)

452Case SymbolKind.Field, 453SymbolKind.Local, 454SymbolKind.Method, 455SymbolKind.Parameter, 456SymbolKind.Property, 457SymbolKind.RangeVariable

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\InvocationExpressionSyntaxExtensions.vb (2)

50Return symbol IsNot Nothing AndAlso symbol.MatchesKind(SymbolKind.Property, SymbolKind.Method) AndAlso Not symbol.IsAnonymousFunction

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (3)

283If symbol.MatchesKind(SymbolKind.Local, SymbolKind.Field, SymbolKind.Property) Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (2)

249If symbol?.Kind = SymbolKind.Field OrElse symbol?.Kind = SymbolKind.Property Then

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

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicCommonGenerationServiceMethods.vb (2)

31Return symbol.Kind = SymbolKind.Namespace Or symbol.Kind = SymbolKind.NamedType Or AreSpecialOptionsActive(semanticModel)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationHelpers.vb (4)

206If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event) Then 215If modifiedIdentifierNode IsNot Nothing AndAlso symbol.IsKind(SymbolKind.Field) AndAlso GetType(T) Is GetType(FieldDeclarationSyntax) Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Editing\VisualBasicImportAdder.vb (1)

49If Symbol IsNot Nothing AndAlso Symbol.Kind <> SymbolKind.Namespace AndAlso nsSymbol IsNot Nothing Then

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

799Case SymbolKind.NamedType 801Case SymbolKind.Alias

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

12If symbol.Kind <> SymbolKind.Namespace OrElse symbol.Name <> "My" Then 24If symbol.Kind <> SymbolKind.Property OrElse symbol.Name <> "Forms" Then

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

43While underlyingNonArrayType.Kind = SymbolKind.ArrayType

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicTypeInferenceService.TypeInferrer.vb (3)

613Case SymbolKind.Field 615Case SymbolKind.Local 985SemanticModel.GetSymbolInfo(identifier.Identifier, CancellationToken).Symbol?.Kind = SymbolKind.Parameter Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Utilities\SymbolExtensions.vb (1)

15If symbol.IsKind(SymbolKind.Property) AndAlso symbol.IsImplicitlyDeclared Then

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

CommandLineTests.vb (2)

11029context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType) 11053context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType)

Microsoft.CodeAnalysis.VisualBasic.EditorFeatures (1)

LineCommit\CommitBufferManager.vb (1)

320If refAssemblyOrModule.MatchesKind(SymbolKind.Assembly) Then

Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests (85)

Attributes\AttributeTests_MarshalAs.vb (4)

27For Each typeSym As NamedTypeSymbol In c.GlobalNamespace.GetMembers().Where(Function(s) s.Kind = SymbolKind.NamedType) 28Dim fields = typeSym.GetMembers().Where(Function(s) s.Kind = SymbolKind.Field) 49For Each typeSym As NamedTypeSymbol In c.GlobalNamespace.GetMembers().Where(Function(s) s.Kind = SymbolKind.NamedType) 50Dim methods = typeSym.GetMembers().Where(Function(s) s.Kind = SymbolKind.Method)

Attributes\AttributeTests_Tuples.vb (7)

253Case SymbolKind.Method 257Case SymbolKind.Field 268Case SymbolKind.Method 272Case SymbolKind.NamedType 275Case SymbolKind.Field 277Case SymbolKind.Property 279Case SymbolKind.Event

CodeGen\CodeGenAsyncTests.vb (3)

6190Where member.Kind = SymbolKind.Field 9267Case SymbolKind.Method 9270Case SymbolKind.Field

CodeGen\CodeGenClosureLambdaTests.vb (1)

3497}, c.GetMembers().Where(Function(member) member.Kind = SymbolKind.NamedType).Select(Function(member) member.ToString()))

CodeGen\CodeGenScriptTests.vb (1)

245If symbol.Kind = SymbolKind.NamedType Then

CodeGen\CodeGenTuples.vb (34)

CodeGen\CodeGenVBCore.vb (12)

2861Case SymbolKind.NamedType 2863Case SymbolKind.Namespace 3039Case SymbolKind.Field, 3040SymbolKind.Property 3042Case SymbolKind.Method 3053Case SymbolKind.NamedType 3165Case SymbolKind.Namespace 3180Case SymbolKind.NamedType 3183Where x.Kind <> SymbolKind.NamedType 3240Case SymbolKind.Namespace 3259Case SymbolKind.NamedType 3267Where x.Kind <> SymbolKind.NamedType

Emit\CompilationEmitTests.vb (22)

Emit\EmitMetadata.vb (1)

180Where(Function(m) m.Kind = SymbolKind.Field).

Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler (12)

Binders\EENamedTypeBinder.vb (2)

63If symbol.Kind = SymbolKind.TypeParameter Then 67Debug.Assert(symbols(i).Kind = SymbolKind.TypeParameter)

CompilationContext.vb (6)

784If typeSymbol.Kind = SymbolKind.ErrorType Then 822If namespaceOrTypeSymbol.Kind = SymbolKind.ErrorType Then 853If namespaceOrTypeSymbol.Kind = SymbolKind.ErrorType Then 1018If member.Kind <> SymbolKind.Field Then 1205If member.Kind <> SymbolKind.Field Then 1232If member.Kind <> SymbolKind.Field Then

EvaluationContext.vb (1)

520If member.Kind <> SymbolKind.Field Then

SymbolExtensions.vb (1)

29While containingSymbol IsNot Nothing AndAlso containingSymbol.Kind <> SymbolKind.Namespace

Symbols\EETypeParameterSymbol.vb (2)

24Debug.Assert(container.Kind = SymbolKind.NamedType OrElse container.Kind = SymbolKind.Method)

Microsoft.CodeAnalysis.VisualBasic.Features (37)

ChangeSignature\VisualBasicChangeSignatureService.vb (1)

132If typeSymbol IsNot Nothing AndAlso typeSymbol.IsKind(SymbolKind.NamedType) AndAlso DirectCast(typeSymbol, ITypeSymbol).TypeKind = TypeKind.Delegate Then

CodeFixes\GenerateEvent\GenerateEventCodeFixProvider.vb (1)

370Any(Function(x) x.MatchesKind(SymbolKind.Event) AndAlso x.Name = handlesClauseItem.EventMember.Identifier.ValueText) Then

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (2)

352(symbol.Kind = SymbolKind.Method OrElse symbol.Kind = SymbolKind.Property) Then

Completion\CompletionProviders\CompletionListTagCompletionProvider.vb (2)

60If member.MatchesKind(SymbolKind.Field, SymbolKind.Property) AndAlso

Completion\CompletionProviders\CrefCompletionProvider.vb (1)

241ElseIf symbol.Kind = SymbolKind.Method Then

Completion\CompletionProviders\EnumCompletionProvider.vb (3)

68If member.Kind = SymbolKind.Field AndAlso DirectCast(member, IFieldSymbol).IsConst AndAlso member.IsEditorBrowsable(options.MemberDisplayOptions.HideAdvancedMembers, syntaxContext.SemanticModel.Compilation) Then 105If symbol.Kind <> SymbolKind.Field Then 150If symbols(0).Symbol.Kind = SymbolKind.Field Then

Completion\CompletionProviders\ImplementsClauseCompletionProvider.vb (2)

113If symbol.Kind = SymbolKind.Alias Then 292Return symbol.MatchesKind(SymbolKind.NamedType) AndAlso symbol.GetAllTypeArguments().Any()

Completion\CompletionProviders\OverrideCompletionProvider.vb (2)

172Dim filteredMembers = members.Where(Function(m) m.Kind = SymbolKind.Property) 184Return members.WhereAsArray(Function(m) Not m.IsKind(SymbolKind.Event))

Debugging\ProximityExpressionsGetter.vb (1)

81If info.Symbol.Kind = SymbolKind.Local Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (6)

786If oldSymbol.Kind = SymbolKind.Parameter Then 788ElseIf oldSymbol.Kind = SymbolKind.TypeParameter Then 1999Case SymbolKind.Method 2012Case SymbolKind.NamedType 2034Case SymbolKind.Method 2044Case SymbolKind.Field

ExtractMethod\Extensions.vb (2)

140Dim methodSymbols = model.GetSymbolInfo(invocation, cancellationToken).GetAllSymbols().Where(Function(s) s.Kind = SymbolKind.Method).Cast(Of IMethodSymbol)() 469Return type Is Nothing OrElse type.Kind = SymbolKind.ErrorType

GenerateType\VisualBasicGenerateTypeService.vb (4)

134Not leftSymbol.IsKind(SymbolKind.Namespace) OrElse 168If leftSymbol IsNot Nothing And leftSymbol.IsKind(SymbolKind.Namespace) Then 331If symbol IsNot Nothing AndAlso symbol.IsKind(SymbolKind.Method) Then 359Return If(memberGroup.ElementAt(0).IsKind(SymbolKind.Method), DirectCast(memberGroup.ElementAt(0), IMethodSymbol), Nothing)

LanguageServices\VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb (1)

170If method IsNot Nothing AndAlso method.ContainingSymbol.IsKind(SymbolKind.Method) Then

NavigationBar\VisualBasicNavigationBarItemService.vb (5)

162Where member.IsShared AndAlso member.Kind = Global.Microsoft.CodeAnalysis.SymbolKind.Field 270If symbol.Kind = SymbolKind.Method Then 282If symbol.Kind = SymbolKind.Property Then 287If symbol.Kind = SymbolKind.Event Then 291If symbol.Kind = SymbolKind.Field AndAlso Not symbol.IsImplicitlyDeclared Then

SignatureHelp\GenericNameSignatureHelpProvider.Method.vb (1)

31If result.Kind <> SymbolKind.NamedType OrElse Not DirectCast(result, INamedTypeSymbol).IsScriptClass Then

SignatureHelp\RaiseEventStatementSignatureHelpProvider.vb (1)

84Dim allowedEvents = events.WhereAsArray(Function(s) s.Kind = SymbolKind.Event AndAlso Equals(s.ContainingType, containingType)).

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicCommonGenerationServiceMethods.vb (2)

31Return symbol.Kind = SymbolKind.Namespace Or symbol.Kind = SymbolKind.NamedType Or AreSpecialOptionsActive(semanticModel)

Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (465)

Binding\Binder_Expressions_Tests.vb (14)

Binding\ImplicitVariableTests.vb (12)

889symbolKind:=SymbolKind.Local) 899symbolKind:=SymbolKind.Method) 921symbolKind:=SymbolKind.Method, 935symbolKind:=SymbolKind.Method, 1025Assert.Equal(SymbolKind.Local, l1.Kind) 1030Assert.Equal(SymbolKind.Local, l2.Kind) 1067Assert.Equal(SymbolKind.Local, l2.Kind) 1072Assert.Equal(SymbolKind.Local, l1.Kind) 1239Private Sub VerifySemanticInfo(semanticInfo As SemanticInfoSummary, expectedType As TypeSymbol, symbolKind? As SymbolKind, expectedSymbol As String) 1259Private Sub VerifySemanticInfoSummary(semanticInfo As SemanticInfoSummary, expectedType As TypeSymbol, symbolKind? As SymbolKind) 1280VerifySemanticInfoSummary(semanticInfo, objectSymbol, SymbolKind.Local) 1283Private Sub VerifyImplicitDeclarationBindExpression(code As XCData, expression As String, expectedTypeName As String, Optional symbolKind? As SymbolKind = Nothing, Optional expectedSymbol As String = Nothing)

Binding\MethodBodyBindingTests.vb (2)

338Assert.Equal(SymbolKind.Local, sym1.Kind) 343Assert.Equal(SymbolKind.Local, sym2.Kind)

Compilation\CompilationAPITests.vb (4)

1068Assert.Equal(smb.Kind, SymbolKind.Assembly) 1488Assert.Equal(CInt(SymbolKind.NamedType), CInt(tupleWithoutNames.Kind)) 1504Assert.Equal(SymbolKind.NamedType, tupleWithNames.Kind) 2577If children1(i).Kind = SymbolKind.Namespace Then

Compilation\MyTemplateTests.vb (1)

297Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind)

Compilation\SemanticModelAPITests.vb (38)

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (15)

Compilation\SemanticModelLookupSymbolsAPITests.vb (1)

106Assert.Equal(SymbolKind.Local, syms(0).Kind)

DeclaringSyntaxNodeTests.vb (29)

Diagnostics\DiagnosticAnalyzerTests.vb (3)

312context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.NamedType) 506context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.Field) 1644Dim analyzers = New DiagnosticAnalyzer() {New SymbolStartAnalyzer(topLevelAction:=False, SymbolKind.NamedType)}

Diagnostics\GetDiagnosticsTests.vb (1)

729SymbolKind.NamedType)

ExtensionMethods\SemanticModelTests.vb (5)

60Assert.Equal(SymbolKind.Method, method.Kind) 128Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind) 188Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind) 1343Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind) 1392Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)

FlowAnalysis\FlowTestBase.vb (3)

43Case SymbolKind.Method 46Case SymbolKind.NamedType 50Case SymbolKind.[Namespace]

Semantics\AnonymousTypesTests.vb (3)

1497Assert.Equal(SymbolKind.Parameter, symbol2.Kind) 1542Assert.Equal(SymbolKind.Parameter, symbol2.Kind) 1587Assert.Equal(SymbolKind.Parameter, symbol2.Kind)

Semantics\BinaryOperators.vb (1)

1107If m.Kind = SymbolKind.Method Then

Semantics\GetExtendedSemanticInfoTests.vb (209)

Semantics\GetSemanticInfoTests.vb (53)

Semantics\GotoTests.vb (8)

Semantics\LambdaSemanticInfoTests.vb (13)

Semantics\NameOfTests.vb (5)

140Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind) 1531Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind) 1869Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind) 2886Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind) 2951Assert.Equal(SymbolKind.ErrorType, typeInfo.Type.Kind)

Semantics\NativeIntegerTests.vb (1)

52Assert.Equal(SymbolKind.NamedType, type.Kind)

Semantics\NewOnInterfaceTests.vb (7)

1199Assert.Equal(SymbolKind.NamedType, semanticInfo.Symbol.Kind) 1237Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind) 1241Assert.Equal(SymbolKind.NamedType, semanticInfo.Type.Kind) 1245Assert.Equal(SymbolKind.NamedType, semanticInfo.Type.Kind) 1281Assert.Equal(SymbolKind.Local, semanticInfo.Symbol.Kind) 1285Assert.Equal(SymbolKind.NamedType, semanticInfo.Type.Kind) 1289Assert.Equal(SymbolKind.NamedType, semanticInfo.Type.Kind)

Semantics\NonTrailingNamedArgumentsTests.vb (2)

73Assert.Equal(SymbolKind.Parameter, firstASymbol.Symbol.Kind) 85Assert.Equal(SymbolKind.Parameter, secondASymbol.Symbol.Kind)

Semantics\OptionalArgumentTests.vb (1)

1063Assert.Equal(SymbolKind.NamedType, semanticSummary.Symbol.Kind)

Semantics\QueryExpressions_SemanticModel.vb (1)

3367Assert.Equal(SymbolKind.Method, semanticInfo.Symbol.Kind)

Semantics\RefFieldTests.vb (1)

167Dim fieldMembers = containingType.GetMembers().WhereAsArray(Function(m) m.Kind = SymbolKind.Field)

Semantics\SelectCaseTests.vb (11)

Semantics\SyncLockTests.vb (2)

246Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind) 477Assert.Equal(SymbolKind.Parameter, semanticSummary.Symbol.Kind)

Semantics\TypeOfTests.vb (2)

751Assert.Equal(SymbolKind.Alias, aliasSymbol.Kind) 767Assert.Equal(SymbolKind.Local, symbolInfo.Symbol.Kind)

Semantics\UsingStatementTest.vb (4)

327Assert.Equal(SymbolKind.Local, symbol.Kind) 344If (type.Symbol.Kind = SymbolKind.Method) Then 357ElseIf (type.Symbol.Kind = SymbolKind.Field) Then 377Assert.Equal(SymbolKind.Local, ActualSymbol.Kind)

Semantics\VariableTypeInference.vb (1)

709Assert.Equal(SymbolKind.Local, varSymbol.Kind)

Semantics\WithBlockSemanticModelTests.vb (12)

Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests (496)

DocumentationComments\DocCommentTests.vb (72)

SymbolDisplay\SymbolDisplayTests.vb (1)

5359Dim indexer = type.GetMembers().Where(Function(m) m.Kind = SymbolKind.Property AndAlso DirectCast(m, IPropertySymbol).IsIndexer).Single()

SymbolsTests\AnonymousTypes\AnonymousTypesSemanticsTests.vb (5)

158If member.Kind = SymbolKind.Property Then 434If member.Kind = If(isType, SymbolKind.Property, SymbolKind.Parameter) Then 1241Assert.Equal(SymbolKind.RangeVariable, querySymbol.Kind) 1245Assert.Equal(SymbolKind.RangeVariable, querySymbol.Kind)

SymbolsTests\AssemblyAndNamespaceTests.vb (12)

SymbolsTests\CompilationCreationTests.vb (117)

SymbolsTests\Metadata\MetadataMemberTests.vb (16)

SymbolsTests\Metadata\MetadataTypeTests.vb (14)

SymbolsTests\Metadata\PE\BaseTypeResolution.vb (9)

SymbolsTests\Metadata\PE\LoadingEvents.vb (4)

87Assert.Equal(SymbolKind.[Event], instanceEvent.Kind) 95Assert.Equal(SymbolKind.[Event], staticEvent.Kind) 236Dim outerInterfaceEvent = outerInterface.GetMembers().Where(Function(m) m.Kind = SymbolKind.[Event]).Single() 243Dim innerInterfaceEvent = innerInterface.GetMembers().Where(Function(m) m.Kind = SymbolKind.[Event]).Single()

SymbolsTests\Metadata\PE\LoadingFields.vb (1)

48Assert.Equal(SymbolKind.Field, f1.Kind)

SymbolsTests\Metadata\PE\LoadingGenericTypeParameters.vb (1)

71Assert.Equal(SymbolKind.TypeParameter, C1_T.Kind)

SymbolsTests\Metadata\PE\LoadingMethods.vb (4)

67Assert.Equal(SymbolKind.Parameter, m1_1.Kind) 92Assert.Equal(SymbolKind.NamedType, C108.Kind) 97Assert.Equal(SymbolKind.Method, sameName(0).Kind) 99Assert.Equal(SymbolKind.NamedType, sameName(1).Kind)

SymbolsTests\Metadata\PE\MissingTypeReferences.vb (15)

SymbolsTests\Metadata\PE\NoPia.vb (63)

SymbolsTests\Metadata\PE\NoPiaInstantiationOfGenericClassAndStruct.vb (32)

SymbolsTests\Metadata\PE\NoPiaLocalHideAndTypeSubstitutionTests.vb (1)

288Assert.Equal(SymbolKind.NamedType, embeddedType.ReturnType.Kind)

SymbolsTests\Metadata\PE\TypeAccessibility.vb (6)

29Where n.Kind = SymbolKind.Namespace AndAlso n.Name.Equals("System")). 62Where t.Kind = SymbolKind.Namespace AndAlso t.Name.Equals("Runtime")). 66Where t.Kind = SymbolKind.Namespace AndAlso t.Name.Equals("Remoting")). 70Where t.Kind = SymbolKind.Namespace AndAlso t.Name.Equals("Messaging")). 82Where t.Kind = SymbolKind.Namespace AndAlso t.Name.Equals("Security")). 86Where t.Kind = SymbolKind.Namespace AndAlso t.Name.Equals("AccessControl")).

SymbolsTests\Metadata\WinMdEventTest.vb (2)

1467Assert.Equal(SymbolKind.Local, symbol.Kind) 1701Assert.Equal(SymbolKind.Field, symbol.Kind)

SymbolsTests\MockSymbolTests.vb (2)

25Assert.Equal(SymbolKind.ArrayType, ats1.Kind) 33Assert.Equal(SymbolKind.ArrayType, ats2.Kind)

SymbolsTests\Retargeting\NoPia.vb (27)

SymbolsTests\Retargeting\RetargetingTests.vb (2)

161ElseIf aAssociated.Kind = SymbolKind.Property Then 2194Assert.Equal(SymbolKind.Event, RetargetEventItem.Kind)

SymbolsTests\Source\BaseClassTests.vb (2)

2077Assert.Equal(SymbolKind.ErrorType, x.BaseType.Kind) 2078Assert.Equal(SymbolKind.ErrorType, y.BaseType.Kind)

SymbolsTests\Source\BindingsTests.vb (6)

480Assert.Equal(SymbolKind.NamedType, symbol.Kind) 491Assert.Equal(SymbolKind.NamedType, symbol.Kind) 507Assert.Equal(SymbolKind.NamedType, sortedSymbols(0).Kind) 510Assert.Equal(SymbolKind.NamedType, sortedSymbols(1).Kind) 523Assert.Equal(SymbolKind.NamedType, symbols(0).Kind) 680Assert.Equal(SymbolKind.NamedType, info.Type.Kind)

SymbolsTests\Source\ComClassTests.vb (7)

29m.Kind <> SymbolKind.NamedType OrElse 59Case SymbolKind.NamedType 62Case SymbolKind.Method 65Case SymbolKind.Property 68Case SymbolKind.Event 71Case SymbolKind.Field 8082Return s.Kind = SymbolKind.NamedType OrElse s.Name = "dfoo"

SymbolsTests\Source\EventTests.vb (7)

1575Assert.Equal(SymbolKind.NamedType, semanticSummary.Symbol.Kind) 1613Assert.Equal(SymbolKind.Event, semanticSummary.Symbol.Kind) 1655Assert.Equal(SymbolKind.Field, sortedCandidates(0).Kind) 1691Assert.Equal(SymbolKind.Field, semanticSummary.Symbol.Kind) 1722Assert.Equal(SymbolKind.Field, mems(1).Kind) 1727Assert.Equal(SymbolKind.Event, mems(3).Kind) 1799Assert.Equal(SymbolKind.Event, semanticSummary.Symbol.Kind)

SymbolsTests\Source\GroupClassTests.vb (7)

3277Assert.Equal(SymbolKind.NamedType, symbolInfo.CandidateSymbols.Single().Kind) 3286Assert.Equal(SymbolKind.Field, symbolInfo.Symbol.Kind) 3358Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind) 3764Assert.Equal(SymbolKind.NamedType, symbolInfo.Symbol.Kind) 3772Assert.Equal(SymbolKind.Property, symbolInfo.Symbol.Kind) 3780Assert.Equal(SymbolKind.Property, symbolInfo.Symbol.Kind) 3788Assert.Equal(SymbolKind.Property, symbolInfo.Symbol.Kind)

SymbolsTests\Source\OverridesTests.vb (5)

2482Where memb.Kind = SymbolKind.Method 2485Where memb.Kind = SymbolKind.Method 2488Where memb.Kind = SymbolKind.Method 2491Where memb.Kind = SymbolKind.Method 6729If member.Kind = SymbolKind.Property Then

SymbolsTests\Source\SourceSymbolTests.vb (2)

86Assert.Equal(SymbolKind.Parameter, r1Type.Kind) 92Assert.Equal(SymbolKind.Parameter, r2Type.Kind)

SymbolsTests\Source\TypeTests.vb (44)

SymbolsTests\SymbolErrorTests.vb (5)

20995Assert.Equal(SymbolKind.ErrorType, sym.Kind) 22491Assert.Equal(SymbolKind.ErrorType, errTypeSym.Kind) 23427Assert.Equal(SymbolKind.ErrorType, typ.Kind) 23457Assert.Equal(SymbolKind.ErrorType, typ.Kind) 23493Assert.Equal(SymbolKind.ErrorType, typ.Kind)

SymbolsTests\WellKnownTypeValidationTests.vb (4)

460Assert.Equal(SymbolKind.ErrorType, symbol.Kind) ' Not available 462Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind) 592Assert.True(SymbolKind.ErrorType <> symbol.Kind, $"{symbol} should not be an error type") 675Assert.True(SymbolKind.ErrorType <> symbol.Kind, $"{symbol} should not be an error type")

UsedAssembliesTests.vb (1)

83Dim hasCoreLibraryRef As Boolean = comp.ObjectType.Kind = SymbolKind.NamedType

Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (2)

BasicTrackingDiagnosticAnalyzer.vb (1)

14Protected Overrides Function IsOnCodeBlockSupported(symbolKind As SymbolKind, methodKind As MethodKind, returnsVoid As Boolean) As Boolean

Extensions.vb (1)

197If typeSym.Kind = SymbolKind.NamedType AndAlso

Microsoft.CodeAnalysis.VisualBasic.Workspaces (104)

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

169(symbol.IsKind(SymbolKind.Method) AndAlso DirectCast(symbol, IMethodSymbol).MethodKind = MethodKind.Constructor)

Classification\SyntaxClassification\NameSyntaxClassifier.vb (7)

102Case SymbolKind.Namespace 109Case SymbolKind.Method 115Case SymbolKind.Event 118Case SymbolKind.Property 121Case SymbolKind.Field 127Case SymbolKind.Parameter 130Case SymbolKind.Local

FindSymbols\VisualBasicReferenceFinder.vb (2)

26If symbol.Kind = SymbolKind.Property Then 28ElseIf symbol.Kind = SymbolKind.NamedType Then

Recommendations\VisualBasicRecommendationServiceRunner.vb (24)

Rename\LocalConflictVisitor.vb (2)

153If symbol IsNot Nothing AndAlso symbol.IsKind(SymbolKind.Local) Then 197If symbol IsNot Nothing AndAlso symbol.IsKind(SymbolKind.Local) Then

Rename\VisualBasicRenameRewriterLanguageService.vb (20)

Simplification\Reducers\VisualBasicEscapingReducer.vb (1)

103If symbol IsNot Nothing AndAlso symbol.Kind = SymbolKind.Method AndAlso Not DirectCast(symbol, IMethodSymbol).IsConstructor Then

Simplification\Reducers\VisualBasicExtensionMethodReducer.vb (2)

40If (targetSymbol.Symbol IsNot Nothing) AndAlso targetSymbol.Symbol.Kind = SymbolKind.Method Then 63If newSymbol.Kind = SymbolKind.Method And oldSymbol.Equals(DirectCast(newSymbol, IMethodSymbol).GetConstructedReducedFrom()) Then

Simplification\Simplifiers\AbstractVisualBasicSimplifier.vb (2)

101(symbol.Kind <> SymbolKind.Namespace AndAlso symbol.Kind <> SymbolKind.NamedType) Then

Simplification\Simplifiers\ExpressionSimplifier.vb (3)

131If (symbol IsNot Nothing AndAlso symbol.IsKind(SymbolKind.NamedType)) Then 237If leftSymbol IsNot Nothing AndAlso leftSymbol.Kind = SymbolKind.NamedType Then 239If rightSymbol IsNot Nothing AndAlso (rightSymbol.IsStatic OrElse rightSymbol.Kind = SymbolKind.NamedType) Then

Simplification\Simplifiers\NameSimplifier.vb (3)

42If symbol.Kind = SymbolKind.Method AndAlso symbol.IsConstructor() Then 46If symbol.Kind = SymbolKind.Method AndAlso name.Kind = SyntaxKind.GenericName Then 197If (symbol.Kind = SymbolKind.NamedType) AndAlso (Not name.IsLeftSideOfQualifiedName) Then

Simplification\VisualBasicSimplificationService.Expander.vb (10)

107If newNodeSymbol IsNot Nothing AndAlso newNodeSymbol.Kind = SymbolKind.Parameter Then 321If symbol.MatchesKind(SymbolKind.Local, SymbolKind.Field, SymbolKind.Property) Then 634If symbol.Kind = SymbolKind.NamedType OrElse symbol.Kind = SymbolKind.Namespace Then 644If symbol.Kind = SymbolKind.Method OrElse 645symbol.Kind = SymbolKind.Field OrElse 646symbol.Kind = SymbolKind.Property Then 685If newNode.Kind = SyntaxKind.IdentifierName AndAlso symbol.Kind = SymbolKind.Method Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ExpressionSyntaxExtensions.vb (6)

452Case SymbolKind.Field, 453SymbolKind.Local, 454SymbolKind.Method, 455SymbolKind.Parameter, 456SymbolKind.Property, 457SymbolKind.RangeVariable

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\InvocationExpressionSyntaxExtensions.vb (2)

50Return symbol IsNot Nothing AndAlso symbol.MatchesKind(SymbolKind.Property, SymbolKind.Method) AndAlso Not symbol.IsAnonymousFunction

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Extensions\ParenthesizedExpressionSyntaxExtensions.vb (3)

283If symbol.MatchesKind(SymbolKind.Local, SymbolKind.Field, SymbolKind.Property) Then

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\VisualBasic\Services\SemanticFacts\VisualBasicSemanticFacts.vb (2)

249If symbol?.Kind = SymbolKind.Field OrElse symbol?.Kind = SymbolKind.Property Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationHelpers.vb (4)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Editing\VisualBasicImportAdder.vb (1)

49If Symbol IsNot Nothing AndAlso Symbol.Kind <> SymbolKind.Namespace AndAlso nsSymbol IsNot Nothing Then

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

799Case SymbolKind.NamedType 801Case SymbolKind.Alias

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

12If symbol.Kind <> SymbolKind.Namespace OrElse symbol.Name <> "My" Then 24If symbol.Kind <> SymbolKind.Property OrElse symbol.Name <> "Forms" Then

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

43While underlyingNonArrayType.Kind = SymbolKind.ArrayType

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\LanguageServices\VisualBasicTypeInferenceService.TypeInferrer.vb (3)

613Case SymbolKind.Field 615Case SymbolKind.Local 985SemanticModel.GetSymbolInfo(identifier.Identifier, CancellationToken).Symbol?.Kind = SymbolKind.Parameter Then

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\Utilities\SymbolExtensions.vb (1)

15If symbol.IsKind(SymbolKind.Property) AndAlso symbol.IsImplicitlyDeclared Then

Microsoft.CodeAnalysis.Workspaces (312)

Editing\SyntaxGenerator.cs (14)

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.cs (8)

697case SymbolKind.Namespace: 707case SymbolKind.NamedType: 714case SymbolKind.Method: 715case SymbolKind.Property: 716case SymbolKind.Field: 717case SymbolKind.Event: 718case SymbolKind.Parameter: 719case SymbolKind.Local:

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)

77if (current.Kind == SymbolKind.Field) 82if (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)

49if (searchSymbol.Kind == SymbolKind.Namespace && symbolToMatch.Kind == SymbolKind.Namespace)

Recommendations\AbstractRecommendationService.cs (7)

77case SymbolKind.NamedType: 86case SymbolKind.Method: 100case SymbolKind.Event: 101case SymbolKind.Field: 102case SymbolKind.Property: 106case SymbolKind.TypeParameter: 120return 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)

238if (renamedSymbol.ContainingSymbol.IsKind(SymbolKind.NamedType)) 252.Where(s => !s.MatchesKind(SymbolKind.Method, SymbolKind.Property) || 253!renamedSymbol.MatchesKind(SymbolKind.Method, SymbolKind.Property)); 258.Where(s => s.Kind != SymbolKind.Method || renamedSymbol.Kind != SymbolKind.Method); 264if (renamedSymbol.IsKind(SymbolKind.Namespace) && renamedSymbol.ContainingSymbol.IsKind(SymbolKind.Namespace)) 268!s.IsKind(SymbolKind.Namespace) && 274if (renamedSymbol.IsKind(SymbolKind.NamedType) && renamedSymbol.ContainingSymbol is INamespaceOrTypeSymbol) 280var conflictingSymbolLocations = otherThingsNamedTheSame.Where(s => !s.IsKind(SymbolKind.Namespace)); 281if (otherThingsNamedTheSame.Any(s => s.IsKind(SymbolKind.Namespace)))

Rename\ConflictEngine\ConflictResolver.Session.cs (1)

669newReferencedSymbols = 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\INamedTypeSymbolExtensions.cs (6)

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

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

604case SymbolKind.NamedType: 615case SymbolKind.TypeParameter:

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\Core\Utilities\SignatureComparer.cs (6)

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

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

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

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

79public override SymbolKind Kind => SymbolKind.Method;

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

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

44public override SymbolKind Kind => SymbolKind.Event;

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

49public override SymbolKind Kind => SymbolKind.Field;

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

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

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

56public override SymbolKind Kind => SymbolKind.Property;

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

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

33s.Kind is SymbolKind.Local or 34SymbolKind.Parameter or 35SymbolKind.RangeVariable or 36SymbolKind.Field or 37SymbolKind.Property || 38s 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)

133if (symbol.IsKind(SymbolKind.Namespace, out INamespaceSymbol? ns)) 143else if (symbol.IsKind(SymbolKind.Assembly) || 144symbol.IsKind(SymbolKind.NetModule) || 145symbol.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)

134var typeSymbol = result.Where(@ref => @ref.Definition.Kind == SymbolKind.NamedType).Single(); 547var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType); 548var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 580var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType); 581var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 622var typeResult = result.Single(r => r.Definition.Kind == SymbolKind.NamedType); 623var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method);

Options\EditorConfigNamingStyleParserTests.cs (27)

Options\NamingStylePreferencesTests.cs (1)

195[InlineData(typeof(SymbolKind))]

SymbolKeyTests.cs (4)

1096Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1131Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1178Assert.Equal(SymbolKind.ErrorType, propType.Kind); 1225Assert.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)

142}, 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 (111)

CallHierarchy\CallHierarchyProvider.cs (8)

57if (symbol.Kind is SymbolKind.Method or 58SymbolKind.Property or 59SymbolKind.Event or 60SymbolKind.Field) 102if (symbol.Kind is SymbolKind.Property or 103SymbolKind.Event or 104SymbolKind.Method) 141if (symbol.Kind == SymbolKind.Field)

CallHierarchy\Finders\AbstractCallFinder.cs (1)

158if (caller.CallingSymbol.Kind == SymbolKind.Field)

CommonControls\MemberSelectionViewModel.cs (2)

142var fields = Members.WhereAsArray(memberViewModel => memberViewModel.Symbol.IsKind(SymbolKind.Field)); 144WhereAsArray(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)

Progression\GraphBuilder.cs (15)

Progression\GraphNodeCreation.cs (10)

33case SymbolKind.Assembly: 36case SymbolKind.Namespace: 39case SymbolKind.NamedType: 42case SymbolKind.Method: 43case SymbolKind.Field: 44case SymbolKind.Property: 45case SymbolKind.Event: 48case SymbolKind.Parameter: 51case SymbolKind.Local: 52case SymbolKind.RangeVariable:

Progression\GraphNodeIdCreation.cs (7)

462(symbol.ContainingSymbol.Kind != SymbolKind.Method && symbol.ContainingSymbol.Kind != SymbolKind.Property)) 469if (containingSymbol is IMethodSymbol method && method.AssociatedSymbol != null && method.AssociatedSymbol.Kind == SymbolKind.Property) 490(symbol.ContainingSymbol.Kind != SymbolKind.Method && symbol.ContainingSymbol.Kind != SymbolKind.Property)) 544if (current is { Kind: SymbolKind.Local or SymbolKind.RangeVariable } && current.Name == symbol.Name)

Progression\GraphProvider.cs (24)

Progression\RoslynGraphProperties.cs (1)

73dataType: typeof(SymbolKind),

Progression\SymbolContainment.cs (5)

56case SymbolKind.NamedType: 57case SymbolKind.Method: 58case SymbolKind.Field: 59case SymbolKind.Property: 60case SymbolKind.Event:

PullMemberUp\VisualStudioPullMemberUpService.cs (1)

53IsMakeAbstractCheckable = !member.IsKind(SymbolKind.Field) && !member.IsAbstract,

Utilities\MemberSymbolViewModel.cs (1)

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

30case SymbolKind.Field: 32case SymbolKind.Method: 34case SymbolKind.Property: 36case SymbolKind.Event: 38case SymbolKind.NamedType: 59case 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.UnitTests (7)

CommonControls\MemberSelectionViewModelTests.vb (1)

102Assert.Empty(checkedMembers.WhereAsArray(Function(analysisResult) analysisResult.Symbol.IsKind(SymbolKind.Field)))

ExtractInterface\ExtractInterfaceViewModelTests.vb (3)

225Assert.Equal("Goo", viewModel.MemberContainers.Where(Function(c) c.Symbol.IsKind(SymbolKind.Property)).Single().SymbolName) 238Assert.Equal("this[int?, [string]]", viewModel.MemberContainers.Where(Function(c) c.Symbol.IsKind(SymbolKind.Property)).Single().SymbolName) 252Assert.Equal("M(string?, IEnumerable<string?>)", viewModel.MemberContainers.Single(Function(c) c.Symbol.IsKind(SymbolKind.Method)).SymbolName)

PullMemberUp\PullMemberUpViewModelTest.vb (3)

134Return Not memberViewModel.Symbol.IsKind(SymbolKind.Field) And Not memberViewModel.Symbol.IsAbstract 177For Each member In viewModel.MemberSelectionViewModel.Members.Where(Function(memberViewModel) memberViewModel.Symbol.IsKind(SymbolKind.Field)) 224For Each member In viewModel.MemberSelectionViewModel.Members.Where(Function(memberViewModel) memberViewModel.Symbol.IsKind(SymbolKind.Field))

Microsoft.VisualStudio.LanguageServices.VisualBasic (24)

CodeModel\MethodXML\MethodXmlBuilder.vb (4)

324If symbol?.Kind = SymbolKind.Property Then 365If leftHandSymbol.Kind = SymbolKind.Alias Then 371If leftHandSymbol.Kind = SymbolKind.Namespace AndAlso 380If leftHandSymbol IsNot Nothing AndAlso leftHandSymbol.Kind = SymbolKind.NamedType Then

CodeModel\VisualBasicCodeModelService.vb (7)

2907(symbol.Kind = SymbolKind.NamedType AndAlso DirectCast(symbol, INamedTypeSymbol).TypeKind = TypeKind.Module) OrElse 3608Protected Overrides Function GetDefaultAccessibility(targetSymbolKind As SymbolKind, destination As CodeGenerationDestination) As Accessibility 3614Case SymbolKind.Field 3616Case SymbolKind.Method, 3617SymbolKind.Property, 3618SymbolKind.Event, 3619SymbolKind.NamedType

CodeModel\VisualBasicCodeModelService_Prototype.vb (6)

35Case SymbolKind.Field 37Case SymbolKind.Property 40Case SymbolKind.Method 43Case SymbolKind.NamedType 48Case SymbolKind.Event 94If symbol.Kind = SymbolKind.Method Then

Help\VisualBasicHelpContextService.vb (4)

101If symbol.MatchesKind(SymbolKind.Alias, SymbolKind.Local, SymbolKind.Parameter, SymbolKind.RangeVariable) Then

Help\VisualBasicHelpContextService.Visitor.vb (1)

447If symbol Is Nothing OrElse symbol.IsKind(SymbolKind.RangeVariable) Then

Progression\VisualBasicProgressionLanguageService.vb (1)

82If symbol.Kind = SymbolKind.Field AndAlso symbol.ContainingType.TypeKind = TypeKind.Enum Then

Venus\ContainedLanguageStaticEventBinding.vb (1)

28Where(Function(m) m.CanBeReferencedByName AndAlso m.Kind = SymbolKind.Method).

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

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

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

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

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

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

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

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

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

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (3)

58compilationContext.RegisterSymbolAction(compilationAnalyzer.AnalyzeNamedType, SymbolKind.NamedType); 105invocationSymbol.Kind == SymbolKind.Method) 135type.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 (2)

CSharpAvoidOptSuffixForNullableEnableCode.cs (2)

93SymbolKind.Property => !symbol.IsOverride 96SymbolKind.Parameter => symbol.ContainingSymbol != null

Roslyn.Diagnostics.VisualBasic.Analyzers (1)

BasicInvokeTheCorrectPropertyToEnsureCorrectUseSiteDiagnostics.vb (1)

69If sym IsNot Nothing AndAlso sym.Kind = SymbolKind.Property Then

Roslyn.Test.PdbUtilities (1)

EditAndContinue\EditAndContinueTest.GenerationVerifier.cs (1)

136.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);

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

Analyzers\MissingPropertySerializationConfiguration\MissingPropertySerializationConfigurationDiagnosticAnalyzer.vb (1)

24context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.Property)

Test.Utilities (47)

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

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

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

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

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

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

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

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

Text.Analyzers (114)

EnumsShouldHavePluralNames.cs (1)

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

IdentifiersShouldBeSpelledCorrectly.cs (28)

253SymbolKind.Namespace, 254SymbolKind.NamedType, 255SymbolKind.Method, 256SymbolKind.Property, 257SymbolKind.Event, 258SymbolKind.Field, 259SymbolKind.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\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)

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

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

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

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

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

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

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