Field

789 references to Field

Analyzer.Utilities.UnitTests (1)

Options\SymbolNamesWithValueOptionTests.cs (1)

233Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Field].ContainsKey("MyNamespace.MyClass.MyField"));

GenerateDocumentationAndConfigFiles (17)

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

ILLink.RoslynAnalyzer (2)

DataFlow\DynamicallyAccessedMembersBinder.cs (1)

461case SymbolKind.Field:

DynamicallyAccessedMembersAnalyzer.cs (1)

170}, SymbolKind.Field);

Metrics (20)

MetricsOutputWriter.cs (1)

81case SymbolKind.Field:

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Metrics.Legacy (21)

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

81case SymbolKind.Field:

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

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

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.AspNetCore.Components.Analyzers (1)

InternalUsageAnalyzer.cs (1)

53SymbolKind.Field,

Microsoft.AspNetCore.Components.SdkAnalyzers (1)

InternalUsageAnalyzer.cs (1)

53SymbolKind.Field,

Microsoft.CodeAnalysis (8)

CodeGen\MetadataNamedArgument.cs (1)

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

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

1180case SymbolKind.Field:

DocumentationCommentId.cs (3)

744kind = SymbolKind.Field; 850case SymbolKind.Field: 1355if (symbol.Kind == SymbolKind.Field)

Emit\EditAndContinue\DefinitionMap.cs (1)

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

SymbolDisplay\AbstractSymbolDisplayVisitor.cs (1)

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

Symbols\SymbolKindExtensions.cs (1)

15case SymbolKind.Field:

Microsoft.CodeAnalysis.Analyzers (26)

MetaAnalyzers\RegisterActionAnalyzer.cs (2)

181nameof(SymbolKind.Field), 365symbol.Kind == SymbolKind.Field &&

MetaAnalyzers\ReportDiagnosticAnalyzer.cs (1)

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

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

65SymbolKind.Field,

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

Microsoft.CodeAnalysis.AnalyzerUtilities (23)

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

312if (analysisEntity.Symbol?.Kind == SymbolKind.Field)

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

47SymbolKind.Field or

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

313Debug.Assert(symbol.Kind is SymbolKind.Local or SymbolKind.Parameter or SymbolKind.Field or SymbolKind.Property);

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

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

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.CodeAnalysis.BannedApiAnalyzers (23)

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

SymbolIsBannedAnalyzerBase.cs (1)

65SymbolKind.Field,

Microsoft.CodeAnalysis.CodeStyle (17)

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

58context.RegisterSymbolAction(AnalyzeFieldSymbol, SymbolKind.Field);

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

783case SymbolKind.Field:

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

228compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 909case SymbolKind.Field:

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

114case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.CodeAnalysis.CodeStyle.Fixes (11)

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

143var fieldNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Field, Accessibility.Private, cancellationToken).ConfigureAwait(false);

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

310CheckSurroundingContext(SymbolKind.Field, cancellationToken); 348if (symbolKind == SymbolKind.Field)

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

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

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

25new SymbolKindOrTypeKind(SymbolKind.Field), 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\RemoveUnusedMembers\AbstractRemoveUnusedMembersCodeFixProvider.cs (1)

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

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (5)

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

165[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)], 197[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)], 229[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)], 261[new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field)], 680new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

Microsoft.CodeAnalysis.CSharp (111)

Binder\Binder.cs (2)

607case SymbolKind.Field: 644symbol.Kind == SymbolKind.Field ||

Binder\Binder.ValueChecks.cs (1)

1686else if (containing.Kind == SymbolKind.Field)

Binder\Binder_AnonymousTypes.cs (1)

196case SymbolKind.Field:

Binder\Binder_Attributes.cs (1)

628case SymbolKind.Field:

Binder\Binder_Await.cs (1)

159case SymbolKind.Field:

Binder\Binder_Expressions.cs (6)

40inStaticContext = memberOpt.Kind == SymbolKind.Field || memberOpt.Kind == SymbolKind.Method || memberOpt.Kind == SymbolKind.Property; 2224case SymbolKind.Field: 3314if (member.Kind == SymbolKind.Field && 7524case SymbolKind.Field: 8333case SymbolKind.Field: 8500case SymbolKind.Field:

Binder\Binder_Lookup.cs (3)

1782case SymbolKind.Field: 1806case SymbolKind.Field: 1822case SymbolKind.Field:

Binder\Semantics\AccessCheck.cs (2)

75case SymbolKind.Field: 203case SymbolKind.Field:

BoundTree\BoundTreeRewriter.cs (1)

136case SymbolKind.Field:

BoundTree\VariablePendingInference.cs (1)

78case SymbolKind.Field:

Compilation\CSharpSemanticModel.cs (3)

3756case SymbolKind.Field: 3783case SymbolKind.Field: 5270case SymbolKind.Field:

Compilation\InitializerSemanticModel.cs (2)

150case SymbolKind.Field: 277case SymbolKind.Field:

Compiler\ClsComplianceChecker.cs (2)

426symbolKind == SymbolKind.Field || 719case SymbolKind.Field:

Compiler\DocumentationCommentCompiler.cs (1)

142symbol.Kind == SymbolKind.Field ||

Compiler\MethodCompiler.cs (1)

576case SymbolKind.Field:

Emitter\EditAndContinue\CSharpDefinitionMap.cs (1)

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

Emitter\Model\PEModuleBuilder.cs (1)

406case SymbolKind.Field:

Emitter\NoPia\EmbeddedType.cs (1)

300case SymbolKind.Field:

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

289Debug.Assert(variableId.Symbol.Kind == SymbolKind.Field || variableId.Symbol.Kind == SymbolKind.Property || variableId.Symbol.Kind == SymbolKind.Event, 773if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 855if ((object)_sourceAssembly != null && variable.Kind == SymbolKind.Field) 1230if (symbol.Kind == SymbolKind.Field) 1808while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property) 2661if (symbol.Kind != SymbolKind.Field)

FlowAnalysis\DefiniteAssignment.VariableIdentifier.cs (1)

32SymbolKind.Field => true,

FlowAnalysis\DefinitelyAssignedWalker.cs (1)

96symbol.Kind != SymbolKind.Field)

FlowAnalysis\EmptyStructTypeCache.cs (1)

196case SymbolKind.Field:

FlowAnalysis\NullableWalker.cs (7)

1151case SymbolKind.Field: 1200if (member.Kind != SymbolKind.Field && 2032case SymbolKind.Field: 2915Debug.Assert(member.Kind == SymbolKind.Field || member.Kind == SymbolKind.Property || member.Kind == SymbolKind.Event); 4704if (members.Any(static m => m.Kind == SymbolKind.Field)) 5795if ((member is PropertySymbol { IsIndexedProperty: false } || member.Kind == SymbolKind.Field) && 7694case SymbolKind.Field:

FlowAnalysis\NullableWalker_Patterns.cs (1)

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

FlowAnalysis\ReadWriteWalker.cs (2)

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)

Lowering\ClosureConversion\ExpressionLambdaRewriter.cs (2)

913case SymbolKind.Field: 928case SymbolKind.Field:

Lowering\LocalRewriter\LocalRewriter_CompoundAssignmentOperator.cs (1)

592Debug.Assert(fieldOrEvent.Kind == SymbolKind.Field || fieldOrEvent.Kind == SymbolKind.Event);

Lowering\LocalRewriter\LocalRewriter_ObjectOrCollectionInitializerExpression.cs (1)

710case SymbolKind.Field:

Lowering\MethodToClassRewriter.cs (1)

405case SymbolKind.Field:

Lowering\StateMachineRewriter\IteratorAndAsyncCaptureWalker.cs (2)

179case SymbolKind.Field: 281case SymbolKind.Field:

Operations\CSharpOperationFactory.cs (1)

869case SymbolKind.Field:

SymbolDisplay\SymbolDisplayVisitor.cs (1)

465&& symbol.Kind == SymbolKind.Field

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

119case SymbolKind.Field:

Symbols\Attributes\AttributeData.cs (2)

290if (foundMember.Kind == SymbolKind.Field || foundMember.Kind == SymbolKind.Property) 706case SymbolKind.Field:

Symbols\BaseTypeAnalysis.cs (1)

186case SymbolKind.Field:

Symbols\Compilation_WellKnownMembers.cs (2)

279targetSymbolKind = SymbolKind.Field; 346case SymbolKind.Field:

Symbols\FieldSymbol.cs (1)

190return SymbolKind.Field;

Symbols\MemberSignatureComparer.cs (1)

524if (member.Kind != SymbolKind.Field)

Symbols\MemberSymbolExtensions.cs (5)

342case SymbolKind.Field: 506case SymbolKind.Field: 566case SymbolKind.Field: 584case SymbolKind.Field: 917case SymbolKind.Field:

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

1206if (staticIndex < staticFields.Length && staticFields[staticIndex].Kind == SymbolKind.Field) 1222Debug.Assert(staticIndex == staticFields.Length || staticFields[staticIndex].Kind != SymbolKind.Field); 1234IEnumerable<FieldSymbol> nonEventFields = GetMembers<FieldSymbol>(this.GetMembers().WhereAsArray(m => !(m is TupleErrorFieldSymbol)), SymbolKind.Field, offset: 0); 1521Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder());

Symbols\MethodSymbolExtensions.cs (1)

112case SymbolKind.Field:

Symbols\NamedTypeSymbol.cs (1)

738case SymbolKind.Field:

Symbols\ObsoleteAttributeHelpers.cs (1)

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

Symbols\OverriddenOrHiddenMembersHelpers.cs (4)

587case SymbolKind.Field: 640case SymbolKind.Field: 716bool needToSearchForRelated = representativeMember.Kind != SymbolKind.Field && representativeMember.Kind != SymbolKind.NamedType && 854Debug.Assert(representativeMember.Kind != SymbolKind.Field);

Symbols\Source\SourceMemberContainerSymbol.cs (6)

1573case SymbolKind.Field: 2109if (symbol.Kind != SymbolKind.Field || !symbol.IsImplicitlyDeclared) 2645case SymbolKind.Field: 2982case SymbolKind.Field: 4569case SymbolKind.Field: 4663case SymbolKind.Field:

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

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

Symbols\Symbol.cs (4)

642case SymbolKind.Field: 1224case SymbolKind.Field: 1659case SymbolKind.Field: 1723case SymbolKind.Field:

Symbols\Symbol_Attributes.cs (1)

51case SymbolKind.Field:

Symbols\SymbolDistinguisher.cs (1)

60case SymbolKind.Field:

Symbols\SymbolExtensions.cs (3)

178case SymbolKind.Field: 479case SymbolKind.Field: 536SymbolKind.Field => ((FieldSymbol)symbol).RequiresInstanceReceiver,

Symbols\SymbolKindExtensions.cs (1)

40case SymbolKind.Field:

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

201SymbolKind.Field => F.Field(F.This(), (FieldSymbol)member), 248if (m.Kind is SymbolKind.Field && m is not TupleErrorFieldSymbol)

Symbols\Synthesized\SynthesizedContainer.cs (1)

129case SymbolKind.Field:

Symbols\Tuples\TupleTypeSymbol.cs (3)

594case SymbolKind.Field: 1015if (member.Kind != SymbolKind.Field) 1068case SymbolKind.Field:

Symbols\TypeSymbolExtensions.cs (1)

1750case SymbolKind.Field:

Microsoft.CodeAnalysis.CSharp.CodeStyle (3)

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

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

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

440case SymbolKind.Field:

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

1232if (symbol?.Kind == SymbolKind.Field)

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

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

86not SymbolKind.Field and

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

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

233[InlineData("int [|m|];", "int M;", SymbolKind.Field, Accessibility.Private)]

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

Completion\CompletionProviders\DeclarationNameCompletionProviderTests.cs (1)

2671SpecificationStyle(new SymbolKindOrTypeKind(SymbolKind.Field), "Field"),

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (7)

34new SymbolKindOrTypeKind(SymbolKind.Field), 52new SymbolKindOrTypeKind(SymbolKind.Field), 87new SymbolKindOrTypeKind(SymbolKind.Field), 105new SymbolKindOrTypeKind(SymbolKind.Field)); 395new SymbolKindOrTypeKind(SymbolKind.Field)); 405new SymbolKindOrTypeKind(SymbolKind.Field)); 469new SymbolKindOrTypeKind(SymbolKind.Field),

Diagnostics\FixAllProvider\BatchFixerTests.cs (1)

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

SymbolKey\SymbolKeyTestBase.cs (2)

168kinds.Add(SymbolKind.Field); 240case SymbolKind.Field:

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

CodeGen\CodeGenAsyncLocalsTests.cs (1)

975IEnumerable<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\CodeGenDeconstructTests.cs (7)

3613Assert.Equal(SymbolKind.Field, field.Kind); 5475Assert.Equal(SymbolKind.Field, firstX1Symbol.Kind); 5480Assert.Equal(SymbolKind.Field, secondX1Symbol.Kind); 5507Assert.Equal(SymbolKind.Field, firstYSymbol.Kind); 5512Assert.Equal(SymbolKind.Field, secondYSymbol.Kind); 5538Assert.Equal(SymbolKind.Field, firstXSymbol.Kind); 5543Assert.Equal(SymbolKind.Field, secondXSymbol.Kind);

CodeGen\CodeGenDynamicTests.cs (1)

684case SymbolKind.Field:

CodeGen\CodeGenTupleTest.cs (2)

17374Assert.Equal(SymbolKind.Field, sym.Symbol.Kind); 17409Assert.Equal(SymbolKind.Field, bobField.Kind);

CodeGen\EventTests.cs (1)

232Assert.Equal(SymbolKind.Field, associatedField.Kind);

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

Attributes\AttributeTests_MarshalAs.cs (1)

36var fields = type.GetMembers().Where(s => s.Kind == SymbolKind.Field);

Attributes\AttributeTests_Tuples.cs (1)

289case SymbolKind.Field:

Diagnostics\DiagnosticAnalyzerTests.cs (7)

516SymbolKind.Namespace, SymbolKind.NamedType, SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.Property); 2902TestSymbolStartAnalyzerCore(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.Field), 2990SymbolKind.Property, SymbolKind.Event, SymbolKind.Field, SymbolKind.Parameter }; 3084SymbolKind.Property, SymbolKind.Event, SymbolKind.Field, SymbolKind.Parameter }; 3144SymbolKind.Property, SymbolKind.Event, SymbolKind.Field, SymbolKind.Parameter }; 3347var analyzer1 = new SymbolStartAnalyzer(topLevelAction: true, SymbolKind.Field, analyzerId: 1); 3348var analyzer2 = new SymbolStartAnalyzer(topLevelAction: true, SymbolKind.Field, analyzerId: 2);

Semantics\OutVarTests.cs (2)

1164Assert.NotEqual(SymbolKind.Field, symbol.Kind); 32734Assert.Equal(SymbolKind.Field, symbol.Kind);

Semantics\PatternMatchingTestBase.cs (2)

194Assert.NotEqual(SymbolKind.Field, symbol.Kind); 245Assert.Equal(SymbolKind.Field, symbol.Kind);

Microsoft.CodeAnalysis.CSharp.Features (16)

CodeRefactorings\UseRecursivePatterns\UseRecursivePatternsCodeRefactoringProvider.cs (1)

524Kind: SymbolKind.Property or SymbolKind.Field,

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

529return [new SymbolKindOrTypeKind(SymbolKind.Field)]; 533new SymbolKindOrTypeKind(SymbolKind.Field), 539possibleTypes = possibleTypes.Remove(new SymbolKindOrTypeKind(SymbolKind.Field)); 545possibleTypes = possibleTypes.Remove(new SymbolKindOrTypeKind(SymbolKind.Field)); 649SymbolKind.Field => Glyph.FieldPublic,

Completion\CompletionProviders\EnumAndCompletionListTagCompletionProvider.cs (1)

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

Completion\CompletionProviders\PropertySubPatternCompletionProvider.cs (1)

146if (symbol.IsKind(SymbolKind.Field))

ConvertAutoPropertyToFullProperty\CSharpConvertAutoPropertyToFullPropertyCodeRefactoringProvider.cs (1)

39new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

ConvertPrimaryToRegularConstructor\ConvertPrimaryToRegularConstructorCodeRefactoringProvider.cs (1)

87new SymbolSpecification.SymbolKindOrTypeKind(SymbolKind.Field),

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (2)

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

NavigationBar\CSharpNavigationBarItemService.cs (1)

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

Snippets\CSharpForEachLoopSnippetProvider.cs (1)

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

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

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

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

86not SymbolKind.Field and

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

ConvertAutoPropertyToFullProperty\ConvertAutoPropertyToFullPropertyTests_OptionSets.cs (3)

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

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

233[InlineData("int [|m|];", "int M;", SymbolKind.Field, Accessibility.Private)]

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

Semantics\ColorColorTests.cs (13)

75SymbolKind.Field, "E F.E", 196SymbolKind.Field, "E F.E", 224SymbolKind.Field, "E F.E", 225SymbolKind.Field, "System.Int32 E.F", 255SymbolKind.Field, "E F.E", 287SymbolKind.Field, "E.Element", 347SymbolKind.Field, "E F.E", 376SymbolKind.Field, "E F.E", 405SymbolKind.Field, "E F.E", 438SymbolKind.Field, "E F.E", 471SymbolKind.Field, "E F.E", 956SymbolKind.Field, "Color.Red"); 1285Assert.Equal(SymbolKind.Field, info.Symbol.Kind);

Semantics\DeconstructionTests.cs (12)

Semantics\InteractiveSemanticModelTests.cs (1)

144Assert.Equal(SymbolKind.Field, symbol.Kind);

Semantics\RefFieldTests.cs (1)

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

Semantics\UnsafeTests.cs (2)

8237Assert.Equal(SymbolKind.Field, receiverSymbol.Kind); 8295Assert.Equal(SymbolKind.Field, receiverSymbol.Kind);

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

Compilation\GetSemanticInfoTests.cs (1)

1533Assert.Equal(SymbolKind.Field, candidate.Kind);

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (2)

1139Assert.Equal(SymbolKind.Field, symbols[0].Kind); 3643Assert.Equal(SymbolKind.Field, symbol.Kind);

Compilation\SemanticModelGetSemanticInfoTests.cs (25)

DocumentationComments\CrefTests.cs (3)

6279Assert.Equal(SymbolKind.Field, symbolInfo.Symbol.Kind); 6285Assert.Equal(SymbolKind.Field, symbolInfo.Symbol.Kind); 6295Assert.Equal(SymbolKind.Field, symbolInfo.Symbol.Kind);

DocumentationComments\DocumentationCommentIDTests.cs (1)

124Assert.Equal(SymbolKind.Field, symbol.Kind);

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

57Assert.Equal(SymbolKind.Field, f1.Kind); 110Assert.Equal(SymbolKind.Field, csFields.GetMembers("Fff").Single().Kind);

Symbols\Retargeting\RetargetingTests.cs (2)

1173case SymbolKind.Field: 1305case SymbolKind.Field:

Symbols\Source\EventTests.cs (2)

101Assert.Equal(SymbolKind.Field, associatedField.Kind); 139Assert.Equal(SymbolKind.Field, associatedField.Kind);

Symbols\Source\FieldTests.cs (1)

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

Symbols\Source\PropertyTests.cs (2)

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

Symbols\StaticAbstractMembersInInterfacesTests.cs (1)

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

Symbols\TypeTests.cs (8)

470Assert.Equal(SymbolKind.Field, field1.Kind); 485Assert.Equal(SymbolKind.Field, field1.Kind); 631Assert.Equal(SymbolKind.Field, m.Kind); 641Assert.Equal(SymbolKind.Field, obj.Kind); 649Assert.Equal(SymbolKind.Field, dyn.Kind); 683Assert.Equal(SymbolKind.Field, symbol.Kind); 907Assert.Equal(SymbolKind.Field, varA.Kind); 1480Assert.Equal(SymbolKind.Field, varX.Kind);

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

Syntax\FieldAndValueKeywordTests.cs (1)

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

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

EmitMetadataTestBase.cs (1)

74var fields = t.GetMembers().Where(m => m.Kind == SymbolKind.Field).OrderBy(f => f.Name).Cast<FieldSymbol>();

Extensions.cs (1)

814case SymbolKind.Field:

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

Metadata\WinMdDumpTest.cs (1)

107case SymbolKind.Field:

Microsoft.CodeAnalysis.CSharp.Workspaces (3)

Simplification\CSharpSimplificationService.Expander.cs (1)

663if (symbol.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property)

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

440case SymbolKind.Field:

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

1232if (symbol?.Kind == SymbolKind.Field)

Microsoft.CodeAnalysis.EditorFeatures (1)

Peek\PeekHelpers.cs (1)

58case SymbolKind.Field:

Microsoft.CodeAnalysis.ExpressionEvaluator.ExpressionCompiler (1)

DkmUtilities.cs (1)

279else if (symbol.Kind == SymbolKind.Field && ((IFieldSymbolInternal)symbol).IsVolatile)

Microsoft.CodeAnalysis.Extensions.Package (5)

Symbols\INamedTypeSymbolExtensions.cs (1)

487case SymbolKind.Field:

Symbols\ISymbolExtensions.cs (1)

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

Symbols\ISymbolExtensions_Accessibility.cs (1)

145case SymbolKind.Field:

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (1)

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.CodeAnalysis.Features (43)

AddImport\SymbolReferenceFinder.cs (1)

310if (symbol?.Kind is SymbolKind.Property or SymbolKind.Field)

ChangeSignature\AbstractChangeSignatureService.cs (2)

292if (symbol.Definition.Kind == SymbolKind.Field) 950.Where(s => s.IsKind(SymbolKind.Property) || s.IsKind(SymbolKind.Field));

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

362case SymbolKind.Field:

Completion\Providers\AbstractContextVariableArgumentProvider.cs (1)

61if (symbol.IsKind(SymbolKind.Field, out IFieldSymbol? field))

Completion\Providers\AbstractObjectInitializerCompletionProvider.cs (1)

96fieldOrProperty.MatchesKind(SymbolKind.Field, SymbolKind.Property) &&

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

186if (symbol.MatchesKind(SymbolKind.Field, SymbolKind.Property))

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (8)

312SymbolKind.Field => GetDisplayName((IFieldSymbol)symbol), 2636case SymbolKind.Field: 3704=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field or SymbolKind.Event; 4281rudeEdit = (oldSymbol.Kind == SymbolKind.Field || newSymbol.Kind == SymbolKind.Field) ? RudeEditKind.FieldKindUpdate : RudeEditKind.Update; 5332case SymbolKind.Field: 5372parameter.ContainingType.GetMembers($"<{parameter.Name}>P").Any(m => m.Kind == SymbolKind.Field); 5727member.Kind is SymbolKind.Field or SymbolKind.Property &&

EditAndContinue\RudeEditReportingCondition.cs (1)

18Contract.ThrowIfFalse(member.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field);

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

204SymbolKind.Field or

ExtractMethod\MethodExtractor.Analyzer.cs (1)

877foreach (var pair in symbolMap.Where(p => p.Key.Kind == SymbolKind.Field))

GenerateType\AbstractGenerateTypeService.Editor.cs (1)

608var fieldNamingRule = await _semanticDocument.Document.GetApplicableNamingRuleAsync(SymbolKind.Field, Accessibility.Private, _cancellationToken).ConfigureAwait(false);

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (2)

247var resource = fieldOrProperty.Kind == SymbolKind.Field 282if (rule.SymbolSpecification.AppliesTo(SymbolKind.Field, Accessibility.Private))

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (2)

34SymbolKind.Field or 46SymbolKind.Field => new WrappedFieldSymbol((IFieldSymbol)m, docCommentFormattingService),

MetadataAsSource\MetadataAsSourceFileService.cs (1)

300case SymbolKind.Field:

PullMemberUp\AbstractPullMemberUpRefactoringProvider.cs (1)

84var allDestinations = selectedMembers.All(m => m.IsKind(SymbolKind.Field))

PullMemberUp\MemberAndDestinationValidator.cs (1)

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

PullMemberUp\MembersPuller.cs (1)

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

Shared\Extensions\ISymbolExtensions_2.cs (1)

38case SymbolKind.Field:

Shared\Utilities\ExtractTypeHelpers.cs (1)

217case SymbolKind.Field:

Snippets\SnippetFunctionService.cs (1)

65var enumFields = typeSymbol.GetMembers().Where(m => m.Kind == SymbolKind.Field && m.IsStatic);

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

58context.RegisterSymbolAction(AnalyzeFieldSymbol, SymbolKind.Field);

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

783case SymbolKind.Field:

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

228compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 909case SymbolKind.Field:

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

114case SymbolKind.Field:

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

143var fieldNamingRule = await document.Document.GetApplicableNamingRuleAsync(SymbolKind.Field, Accessibility.Private, cancellationToken).ConfigureAwait(false);

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

310CheckSurroundingContext(SymbolKind.Field, cancellationToken); 348if (symbolKind == SymbolKind.Field)

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

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

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

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

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

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

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (1)

162([MethodKind.Ordinary, SymbolKind.Field], Capitalization.PascalCase, ReportDiagnostic.Error));

Microsoft.CodeAnalysis.PerformanceSensitiveAnalyzers (22)

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

Microsoft.CodeAnalysis.PublicApiAnalyzers (20)

DeclarePublicApiAnalyzer.cs (1)

146SymbolKind.Field,

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.CodeAnalysis.ResxSourceGenerator (19)

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Microsoft.CodeAnalysis.Test.Utilities (8)

Compilation\CompilationDifference.cs (1)

175var actual = EmitResult.Baseline.SynthesizedMembers.Single(e => e.Key.ToString() == typeName).Value.Where(s => s.Kind == SymbolKind.Field).Select(s => (IFieldSymbol)s.GetISymbol()).Select(f => f.Name + ": " + f.Type);

Compilation\CompilationExtensions.cs (1)

261case SymbolKind.Field:

CompilationVerifier.cs (1)

877.Where(s => s.Kind == SymbolKind.Field)

Diagnostics\CommonDiagnosticAnalyzers.cs (1)

2614SymbolKind.Field);

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (1)

97SymbolKind.Field

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (1)

73SymbolKind.Field,

Diagnostics\TrackingDiagnosticAnalyzer.cs (2)

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

Microsoft.CodeAnalysis.VisualBasic (96)

Analysis\FlowAnalysis\AbstractFlowPass.vb (1)

110Debug.Assert(_info.Symbol.Kind = SymbolKind.Field OrElse

Analysis\FlowAnalysis\AlwaysAssignedWalker.vb (1)

48If v.Exists AndAlso v.Symbol.Kind <> SymbolKind.Field Then

Analysis\FlowAnalysis\DataFlowPass.vb (4)

860If member.Kind = SymbolKind.Field Then 898Case SymbolKind.Field 1111Case SymbolKind.Field 1167Debug.Assert(sym.Kind = SymbolKind.Local OrElse sym.Kind = SymbolKind.Field)

Analysis\FlowAnalysis\DataFlowsInWalker.vb (2)

113Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 118If local.Kind = SymbolKind.Field Then

Analysis\FlowAnalysis\DataFlowsOutWalker.vb (2)

147Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 150If local.Kind = SymbolKind.Field Then

Analysis\FlowAnalysis\DefinitelyAssignedWalker.vb (1)

76symbol.Kind <> SymbolKind.Field Then

Analysis\FlowAnalysis\UnassignedVariablesWalker.vb (2)

42Debug.Assert(local.Kind <> SymbolKind.Field OrElse boundFieldAccess IsNot Nothing) 44If local.Kind = SymbolKind.Field Then

Analysis\IteratorAndAsyncAnalysis\IteratorAndAsyncCaptureWalker.vb (1)

163If symbol.Kind = SymbolKind.Field Then

Binding\Binder_Attributes.vb (2)

460Case SymbolKind.Field 616Case SymbolKind.Field

Binding\Binder_Expressions.vb (7)

1911Case SymbolKind.Field, SymbolKind.Property 2241Case SymbolKind.Field 2585Case SymbolKind.Field, SymbolKind.Method, SymbolKind.Property, SymbolKind.Event 2723Case SymbolKind.Field, SymbolKind.Property 3197Case SymbolKind.Field 3524Case SymbolKind.Field 4008Case SymbolKind.Field

Binding\Binder_Initializers.vb (2)

142Debug.Assert(firstFieldOrProperty.Kind = SymbolKind.Field) 149ElseIf firstFieldOrProperty.Kind = SymbolKind.Field Then

Binding\Binder_Invocation.vb (1)

3127Case SymbolKind.Field, SymbolKind.Property, SymbolKind.Event

Binding\Binder_Lookup.vb (2)

760If sym.Kind <> SymbolKind.Field Then 804If sym.Kind <> SymbolKind.Field Then

Binding\Binder_Statements.vb (1)

4700If member.Kind = SymbolKind.Field AndAlso

Binding\BinderBuilder.vb (3)

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

325fieldOrProperty = containingNamedTypeBinder.ContainingType.FindMember(identifier.ValueText, SymbolKind.Field, identifier.Span, _tree) 357Dim field = containingType.FindMember(identifier.ValueText, SymbolKind.Field, identifier.Span, _tree)

Binding\DeclarationInitializerBinder.vb (2)

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

Binding\DocumentationCommentCrefBinder.vb (2)

384Case SymbolKind.Field 782Case SymbolKind.Field

Binding\DocumentationCommentCrefBinder_Compat.vb (1)

199Case SymbolKind.Field

Binding\InitializerSemanticModel.vb (2)

45If Me.MemberSymbol.Kind = SymbolKind.Field Then 102Case SymbolKind.Field

Binding\LookupResult.vb (2)

740If symbol1.Kind <> SymbolKind.Field OrElse symbol2.Kind <> SymbolKind.Field OrElse symbol1.ContainingType.TypeKind <> TypeKind.Enum Then

Compilation\ClsComplianceChecker.vb (2)

290Debug.Assert(symbol.Kind = SymbolKind.NamedType OrElse symbol.Kind = SymbolKind.Field OrElse symbol.Kind = SymbolKind.Property OrElse symbol.Kind = SymbolKind.Event OrElse symbol.Kind = SymbolKind.Method) 416Case SymbolKind.Field

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

717Case SymbolKind.Field 779Case SymbolKind.Field,

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

98Case SymbolKind.Field

Compilation\DocumentationComments\DocumentationCommentCompiler.vb (1)

118symbol.Kind = SymbolKind.Field OrElse

Compilation\MethodCompiler.vb (1)

473Debug.Assert(fieldOrProperty.Kind = SymbolKind.Field)

Compilation\SemanticModel.vb (2)

1213Case SymbolKind.Method, SymbolKind.Field, SymbolKind.Property 3563Case SymbolKind.Field

Emit\EditAndContinue\VisualBasicDefinitionMap.vb (1)

112If member.Kind = SymbolKind.Field Then

Emit\NoPia\EmbeddedType.vb (1)

235Case SymbolKind.Field

Emit\PEModuleBuilder.vb (1)

246SymbolKind.Field

Lowering\AsyncRewriter\AsyncRewriter.AsyncMethodToClassRewriter.Spilling.vb (1)

535Case SymbolKind.Field

Lowering\ExpressionLambdaRewriter\ExpressionLambdaRewriter.vb (3)

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\LocalRewriter\LocalRewriter_AssignmentOperator.vb (1)

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

Semantics\AccessCheck.vb (1)

121Case SymbolKind.Method, SymbolKind.Property, SymbolKind.Event, SymbolKind.Field

SymbolDisplay\SymbolDisplayVisitor.Members.vb (1)

618Dim isConst = symbol.Kind = SymbolKind.Field AndAlso DirectCast(symbol, IFieldSymbol).IsConst

SymbolDisplay\SymbolDisplayVisitor.vb (1)

394symbol.Kind = SymbolKind.Field AndAlso

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType_TemplateSymbol.vb (1)

120If m.Kind = SymbolKind.Field Then

Symbols\Attributes\AttributeData.vb (1)

566Case SymbolKind.Field

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

215Case SymbolKind.Field 277Case SymbolKind.Field 310symbol.Kind = SymbolKind.Field) 339Case SymbolKind.Field

Symbols\FieldSymbol.vb (1)

179Return SymbolKind.Field

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

392If (Not member.IsShared AndAlso member.Kind = SymbolKind.Field) Then 523Return GetMembers(Of FieldSymbol)(GetMembers(), SymbolKind.Field, offset:=0) 631Case SymbolKind.Field

Symbols\NamedTypeSymbolExtensions.vb (1)

59If child.Kind = SymbolKind.Field OrElse child.Kind = SymbolKind.Property Then

Symbols\Source\LambdaSymbol.vb (2)

131Case SymbolKind.Field 232Case SymbolKind.Field, SymbolKind.Property, SymbolKind.Method

Symbols\Source\LocalSymbol.vb (1)

106container.Kind = SymbolKind.Field OrElse

Symbols\Source\SourceMemberContainerTypeSymbol.vb (1)

3217If member.Kind = SymbolKind.Field Then

Symbols\Source\SourceNamedTypeSymbol.vb (1)

2487If Not m.IsShared And m.Kind = SymbolKind.Field Then

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (1)

380Case SymbolKind.Field, SymbolKind.NamedType

Symbols\SubstitutedNamedType.vb (2)

390Case SymbolKind.Field 494Case SymbolKind.Field

Symbols\Symbol.vb (2)

601SymbolKind.Field, 997Case SymbolKind.Field

Symbols\Symbol_Attributes.vb (1)

68Case SymbolKind.Field

Symbols\SymbolExtensions.vb (3)

53Case SymbolKind.Field, SymbolKind.Local, SymbolKind.Parameter, SymbolKind.RangeVariable 196Case SymbolKind.Field, SymbolKind.Property, SymbolKind.Method, SymbolKind.Event 324Case SymbolKind.Field

Symbols\Tuples\TupleTypeSymbol.vb (3)

666If member.Kind <> SymbolKind.Field Then 719Case SymbolKind.Field 908Case SymbolKind.Field

Symbols\WellKnownMembers.vb (2)

446targetSymbolKind = SymbolKind.Field 499Case SymbolKind.Field

Microsoft.CodeAnalysis.Workspaces (25)

Editing\SyntaxGenerator.cs (3)

721case SymbolKind.Field: 789members: type.GetMembers().Where(s => s.Kind == SymbolKind.Field).Select(Declaration)), 823case SymbolKind.Field:

FindSymbols\Declarations\DeclarationFinder.cs (1)

123SymbolKind.Field;

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

37SymbolKind.Field => true,

FindSymbols\ReferenceLocationExtensions.cs (1)

82if (current.Kind == SymbolKind.Field)

FindSymbols\SymbolFinder_Callers.cs (1)

84SymbolKind.Field)

Recommendations\AbstractRecommendationService.cs (2)

97case SymbolKind.Field: 117return symbol.Kind == SymbolKind.Field ||

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (1)

52if (referencedSymbol.Kind == SymbolKind.Field && originalSymbol.Equals(((IFieldSymbol)referencedSymbol).AssociatedSymbol))

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

Microsoft.CodeAnalysis.Workspaces.UnitTests (10)

EditorConfigParsing\NamingStyleParserTests.cs (6)

82symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind)); 164symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind), 204symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind)); 277symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind), 314symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind)); 351symbolKind => Assert.Equal(new SymbolKindOrTypeKind(SymbolKind.Field), symbolKind));

Options\EditorConfigNamingStyleParserTests.cs (4)

173new SymbolKindOrTypeKind(SymbolKind.Field), 221new SymbolKindOrTypeKind(SymbolKind.Field), 338[InlineData("*", new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })] 339[InlineData(null, new object[] { SymbolKind.Namespace, TypeKind.Class, TypeKind.Struct, TypeKind.Interface, TypeKind.Enum, SymbolKind.Property, MethodKind.Ordinary, MethodKind.LocalFunction, SymbolKind.Field, SymbolKind.Event, TypeKind.Delegate, SymbolKind.Parameter, SymbolKind.TypeParameter, SymbolKind.Local })]

Microsoft.DotNet.CodeAnalysis (1)

Analyzers\MembersMustExistAnalyzer.cs (1)

63context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Field, SymbolKind.Event);

Microsoft.Gen.MetadataExtractor (1)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

705case SymbolKind.Field:

Microsoft.Gen.Metrics (1)

Parser.cs (1)

705case SymbolKind.Field:

Microsoft.Gen.MetricsReports (1)

src\Generators\Microsoft.Gen.Metrics\Parser.cs (1)

705case SymbolKind.Field:

Microsoft.ML.InternalCodeAnalyzer (3)

BestFriendOnPublicDeclarationsAnalyzer.cs (1)

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

36context.RegisterSymbolAction(AnalyzeField, SymbolKind.Field);

Microsoft.VisualStudio.LanguageServices (13)

CallHierarchy\CallHierarchyProvider.cs (2)

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

CallHierarchy\Finders\AbstractCallFinder.cs (1)

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

CommonControls\MemberSelectionViewModel.cs (2)

140var fields = Members.WhereAsArray(memberViewModel => memberViewModel.Symbol.IsKind(SymbolKind.Field)); 142WhereAsArray(memberViewModel => !memberViewModel.Symbol.IsKind(SymbolKind.Field) && !memberViewModel.Symbol.IsAbstract);

ExtractClass\VisualStudioExtractClassOptionsService.cs (1)

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

Implementation\ContainedLanguageRefactorNotifyService.cs (1)

82SymbolKind.Field or

Library\ClassView\AbstractSyncClassViewCommandHandler.cs (1)

90SymbolKind.Field or

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (1)

210case SymbolKind.Field:

Library\ObjectBrowser\Lists\MemberListItem.cs (1)

23case SymbolKind.Field:

Library\VsNavInfo\NavInfoFactory.cs (1)

50SymbolKind.Field or

PullMemberUp\VisualStudioPullMemberUpService.cs (1)

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

Utilities\MemberSymbolViewModel.cs (1)

23public Visibility MakeAbstractVisibility => Symbol.Kind == SymbolKind.Field || Symbol.IsAbstract ? Visibility.Hidden : Visibility.Visible;

Microsoft.VisualStudio.LanguageServices.CSharp (3)

CodeModel\CSharpCodeModelService.cs (1)

2989case SymbolKind.Field:

CodeModel\CSharpCodeModelService_Prototype.cs (2)

29case SymbolKind.Field: 58case VariableDeclaratorSyntax variableDeclarator when symbol.Kind == SymbolKind.Field:

Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (4)

GlyphExtensionsTests.cs (4)

79SymbolKind.Field, 84SymbolKind.Field, 89SymbolKind.Field); 231if (kind == SymbolKind.Field)

Microsoft.VisualStudio.LanguageServices.Implementation (8)

CodeModel\AbstractCodeModelObject_CodeGen.cs (2)

135accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination), 216accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Field, destination),

CodeModel\AbstractCodeModelService.cs (1)

213case SymbolKind.Field:

CodeModel\ExternalElements\ExternalCodeVariable.cs (1)

36case SymbolKind.Field:

CodeModel\InternalElements\CodeVariable.cs (1)

67case SymbolKind.Field:

CodeModel\MethodXml\AbstractMethodXmlBuilder.cs (1)

350case SymbolKind.Field:

Options\Style\NamingPreferences\SymbolSpecification\SymbolSpecificationViewModel.cs (2)

58new SymbolKindViewModel(SymbolKind.Field, ServicesVSResources.NamingSpecification_CSharp_Field, specification), 100new SymbolKindViewModel(SymbolKind.Field, ServicesVSResources.NamingSpecification_VisualBasic_Field, specification),

Roslyn.Diagnostics.Analyzers (26)

AbstractDoNotCopyValue.cs (2)

155SymbolKind.Field, 1521case SymbolKind.Field:

DefaultableTypeShouldHaveDefaultableFieldsAnalyzer.cs (2)

51context.RegisterSymbolAction(context => AnalyzeField(context, nonDefaultableAttribute, knownNonDefaultableTypes), SymbolKind.Field); 66if (member.Kind != SymbolKind.Field)

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field:

Roslyn.Diagnostics.CSharp.Analyzers (2)

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

440case SymbolKind.Field:

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

1232if (symbol?.Kind == SymbolKind.Field)

Roslyn.Test.PdbUtilities (1)

EditAndContinue\EditAndContinueTest.GenerationVerifier.cs (1)

238.Single(e => e.Key.ToString() == typeName).Value.Where(s => s.Kind == SymbolKind.Field)

SemanticSearch.BuildTask (1)

GenerateFilteredReferenceAssembliesTask.cs (1)

352SymbolKind.Field => SymbolKindFlags.Field,

Test.Utilities (14)

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

Text.Analyzers (25)

IdentifiersShouldBeSpelledCorrectly.cs (3)

259SymbolKind.Field, 492SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field 512SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field

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

40SymbolKind.Field or 277SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context), 315SymbolKind.Field => FieldMetricData.Compute((IFieldSymbol)symbol, context),

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

81if (child.Symbol.Kind != SymbolKind.Field || 112var orderedFieldDatas = children.Where(c => c.Symbol.Kind == SymbolKind.Field).OrderBy(c => c.MaintainabilityIndex);

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

162'F' => SymbolKind.Field, 272case SymbolKind.Field:

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

173case SymbolKind.Field:

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

111private static readonly SymbolKindOrTypeKind s_field = new(SymbolKind.Field); 368case SymbolKind.Field:

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

72new SymbolKindOrTypeKind(SymbolKind.Field), 514if (kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsReadOnly) 522if ((kind == SymbolKind.Field && ((IFieldSymbol)symbol).IsConst) ||

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

46SymbolKind.Field => QualifyFieldAccess,

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

487case SymbolKind.Field:

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

272=> symbol is { Kind: SymbolKind.Field, ContainingType.TypeKind: TypeKind.Enum };

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

145case SymbolKind.Field:

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

121SymbolKind.Field => FieldsAreEquivalent((IFieldSymbol)x, (IFieldSymbol)y, equivalentTypesWithDifferingAssemblies),

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

65SymbolKind.Field => CombineHashCodes((IFieldSymbol)x, currentHash),

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

44public override SymbolKind Kind => SymbolKind.Field;

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

34SymbolKind.Field or

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

27case SymbolKind.Field: