Method

Options\SymbolNamesWithValueOptionTests.cs (1)

234Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Method].ContainsKey("MyNamespace.MyClass.MyMethod("));

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

DataFlow\DynamicallyAccessedMembersBinder.cs (1)

462case SymbolKind.Method:

DynamicallyAccessedMembersAnalyzer.cs (1)

146}, SymbolKind.Method);

RequiresAnalyzerBase.cs (1)

68}, SymbolKind.Method);

MetricsOutputWriter.cs (1)

80case SymbolKind.Method:

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

80case SymbolKind.Method:

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

CallAnalysis\Fixers\LegacyLoggingFixer.cs (1)

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

UsingToStringInLoggersAnalyzer.cs (1)

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

ApiLifecycle\AssemblyAnalysis.cs (1)

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

StartupAnalyzer.cs (1)

60if (context.OwningSymbol.Kind != SymbolKind.Method)

InternalUsageAnalyzer.cs (1)

54SymbolKind.Method,

InternalUsageAnalyzer.cs (1)

54SymbolKind.Method,

AttributesShouldNotBeAppliedToPageModelAnalyzer.cs (1)

53}, SymbolKind.Method);

TopLevelParameterNameAnalyzer.cs (1)

81}, SymbolKind.Method);

SymbolApiResponseMetadataProvider.cs (1)

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

Helpers\ISymbolExtensions.cs (1)

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

XmlComments\XmlComment.InheritDoc.cs (1)

78case SymbolKind.Method:

HubClientProxyGenerator.Parser.cs (2)

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

HubServerProxyGenerator.Parser.cs (2)

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

DiagnosticAnalyzer\AnalyzerExecutor.cs (1)

1173case SymbolKind.Method:

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (2)

544case SymbolKind.Method: 583ImmutableArray.Create(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType));

DocumentationCommentId.cs (2)

747kind = SymbolKind.Method; 838case SymbolKind.Method:

Emit\EditAndContinue\SymbolChanges.cs (3)

175if (synthesizedSymbol.Kind == SymbolKind.Method) 201if (synthesizedSymbol.Kind == SymbolKind.Method) 417if (newMember.Kind == SymbolKind.Method)

SymbolDisplay\AbstractSymbolDisplayVisitor_Minimal.cs (1)

73case SymbolKind.Method:

Symbols\SymbolKindExtensions.cs (1)

17case SymbolKind.Method:

MetaAnalyzers\ConfigureGeneratedCodeAnalysisAnalyzer.cs (1)

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

MetaAnalyzers\EnableConcurrentExecutionAnalyzer.cs (1)

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

MetaAnalyzers\RegisterActionAnalyzer.cs (2)

182nameof(SymbolKind.Method), 314if (symbol == null || symbol.Kind != SymbolKind.Method || !symbol.Name.StartsWith("Register", StringComparison.Ordinal))

MetaAnalyzers\ReportDiagnosticAnalyzer.cs (1)

202symbol.Kind != SymbolKind.Method ||

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

64SymbolKind.Method,

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

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

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

1020(symbol.IsReadOnlyFieldOrProperty() || symbol.Kind == SymbolKind.Method) &&

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

46Debug.Assert(owningSymbol.Kind is SymbolKind.Method or

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

SymbolIsBannedAnalyzerBase.cs (1)

64SymbolKind.Method,

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

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

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

782case SymbolKind.Method:

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

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

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

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

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

139.Where(m => m.Kind != SymbolKind.Method);

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

Binder\Binder.cs (4)

447case SymbolKind.Method: 608case SymbolKind.Method: 645symbol.Kind == SymbolKind.Method || 651if (symbol.Kind == SymbolKind.Method)

Binder\Binder.IdentifierUsedAsValueFinder.cs (1)

290Debug.Assert(symbol.Kind != SymbolKind.Method);

Binder\Binder.ValueChecks.cs (1)

1458if (containing.Kind == SymbolKind.Method)

Binder\Binder_AnonymousTypes.cs (1)

193case SymbolKind.Method:

Binder\Binder_Await.cs (1)

169case SymbolKind.Method:

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Crefs.cs (5)

462symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 803if (s.Kind != SymbolKind.Method) 826s.Kind != SymbolKind.Method || ((MethodSymbol)s).Arity == 0); 932case SymbolKind.Method: 1074if (symbol.Kind == SymbolKind.Method)

Binder\Binder_Expressions.cs (11)

Binder\Binder_Lookup.cs (7)

991if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1028if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1378return symbol.Kind == SymbolKind.Method || symbol.IsIndexer(); 1803case SymbolKind.Method: 1824case SymbolKind.Method: 1846case SymbolKind.Method: 1884case SymbolKind.Method:

Binder\Binder_Statements.cs (3)

2959return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningTask(this.Compilation); 2965return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningGenericTask(this.Compilation); 2971if (symbol?.Kind == SymbolKind.Method)

Binder\Binder_Symbols.cs (2)

1489case SymbolKind.Method: 1542if (!haveInstanceCandidates && members[0].Kind == SymbolKind.Method)

Binder\BinderFactory.BinderFactoryVisitor.cs (3)

521return (SourceMemberMethodSymbol)GetMemberSymbol(methodName, baseMethodDeclarationSyntax.FullSpan, container, SymbolKind.Method); 562Debug.Assert(kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event); 601if (kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event)

Binder\ContextualAttributeBinder.cs (1)

58case SymbolKind.Method:

Binder\ForEachLoopBinder.cs (1)

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

Binder\InMethodBinder.cs (2)

272case SymbolKind.Method: 308case SymbolKind.Method:

Binder\LocalBinderFactory.cs (1)

296=> target.Kind == SymbolKind.Method ? new WithMethodTypeParametersBinder((MethodSymbol)target, enclosing) : null;

Binder\LocalScopeBinder.cs (2)

511declaredInThisScope |= newSymbolKind == SymbolKind.Method && this.LocalFunctions.Contains((LocalFunctionSymbol)newSymbol); 524case SymbolKind.Method:

Binder\MethodGroupResolution.cs (1)

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

Binder\Semantics\AccessCheck.cs (3)

76case SymbolKind.Method: 196case SymbolKind.Method when ((MethodSymbol)symbol).MethodKind == MethodKind.LocalFunction: 200case SymbolKind.Method:

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

1461case SymbolKind.Method: 4760case SymbolKind.Method:

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

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

Binder\WithLambdaParametersBinder.cs (1)

139case SymbolKind.Method:

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

197case SymbolKind.Method:

BoundTree\BoundTreeRewriter.cs (1)

142case SymbolKind.Method:

Compilation\CSharpCompilation.cs (1)

3102if (symbol.Kind == SymbolKind.Method && symbol.IsImplicitlyDeclared && ((MethodSymbol)symbol).MethodKind == MethodKind.Constructor)

Compilation\CSharpSemanticModel.cs (4)

3755case SymbolKind.Method: 3776case SymbolKind.Method: 4534case SymbolKind.Method: 4604if (((object)otherSymbol != null) && (otherSymbol.Kind == SymbolKind.Method))

Compilation\MethodBodySemanticModel.cs (1)

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

Compilation\SyntaxTreeSemanticModel.cs (4)

2473case SymbolKind.Method: 2493case SymbolKind.Method: 2529case SymbolKind.Method: 2575case SymbolKind.Method:

Compiler\ClsComplianceChecker.cs (11)

Compiler\DocumentationCommentCompiler.cs (3)

144symbol.Kind == SymbolKind.Method || 661case SymbolKind.Method: 677case SymbolKind.Method:

Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (2)

562case SymbolKind.Method: 598case SymbolKind.Method:

Compiler\MethodBodySynthesizer.cs (1)

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

Compiler\MethodCompiler.cs (1)

517case SymbolKind.Method:

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (1)

451SymbolKind.Method => ((MethodSymbol)otherContainer).TypeParameters,

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

326if (member.Kind == SymbolKind.Method) 1029if (m.Kind == SymbolKind.Method)

Emitter\Model\PEModuleBuilder.cs (2)

388case SymbolKind.Method: 1431return container.Kind == SymbolKind.Method && ((MethodSymbol)container).IsGenericMethod ||

Emitter\Model\TypeParameterSymbolAdapter.cs (2)

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

Emitter\NoPia\EmbeddedEvent.cs (1)

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

Emitter\NoPia\EmbeddedType.cs (1)

303case SymbolKind.Method:

FlowAnalysis\DefiniteAssignment.cs (1)

1808while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property)

FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (1)

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

FlowAnalysis\DefiniteAssignment.VariableIdentifier.cs (1)

36SymbolKind.Method when symbol is MethodSymbol m && m.MethodKind == MethodKind.LocalFunction => true,

FlowAnalysis\NullableWalker.cs (3)

1159case SymbolKind.Method: 7665case SymbolKind.Method: 8672if (symbol.Kind == SymbolKind.Method)

FlowAnalysis\ReadWriteWalker.cs (1)

81while (current?.Kind is SymbolKind.Method or SymbolKind.Field or SymbolKind.Property)

Lowering\AsyncRewriter\AsyncMethodBuilderMemberCollection.cs (1)

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

Lowering\BoundTreeToDifferentEnclosingContextRewriter.cs (1)

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

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

587case SymbolKind.Method:

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

611symbol.Kind == SymbolKind.Method); 657if (symbol.Kind == SymbolKind.Method) 694Debug.Assert(capturedVariable.Kind == SymbolKind.Method);

SymbolDisplay\SymbolDisplayVisitor.cs (1)

383if (symbol.Kind != SymbolKind.Method)

SymbolDisplay\SymbolDisplayVisitor.Types.cs (1)

829if (owner.Kind == SymbolKind.Method)

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

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

Symbols\Attributes\AttributeData.cs (4)

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

Symbols\Compilation_WellKnownMembers.cs (5)

261targetSymbolKind = SymbolKind.Method; 268targetSymbolKind = SymbolKind.Method; 272targetSymbolKind = SymbolKind.Method; 303case SymbolKind.Method: 1192if (typeParam.ContainingSymbol.Kind != SymbolKind.Method)

Symbols\ExtendedErrorTypeSymbol.cs (1)

319case SymbolKind.Method:

Symbols\MemberSignatureComparer.cs (2)

868case SymbolKind.Method: 880return member.Kind == SymbolKind.Method && ((MethodSymbol)member).IsVararg;

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

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) 1475Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder()); 1476Debug.Assert(SymbolKind.Method.ToSortOrder() < SymbolKind.Property.ToSortOrder());

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

644return SymbolKind.Method;

Symbols\MethodSymbolExtensions.cs (1)

109case SymbolKind.Method:

Symbols\NamedTypeSymbol.cs (1)

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

Symbols\OverriddenOrHiddenMembersHelpers.cs (7)

86Debug.Assert(member.Kind == SymbolKind.Method || member.Kind == SymbolKind.Property || member.Kind == SymbolKind.Event); 578if (otherMemberArity == memberArity || (memberKind == SymbolKind.Method && otherMemberArity == 0)) 756if (hiddenMember.Kind != SymbolKind.Method || ((MethodSymbol)hiddenMember).CanBeHiddenByMember(hidingMember)) 879case SymbolKind.Method: 891case SymbolKind.Method: 913case SymbolKind.Method: 1034if (otherMember.Kind == SymbolKind.Method &&

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

1031if (retargetedMember.Kind == SymbolKind.Method)

Symbols\Source\LocalFunctionSymbol.cs (1)

446if (tpEnclosing.ContainingSymbol.Kind == SymbolKind.Method)

Symbols\Source\ModifierUtils.cs (1)

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

Symbols\Source\ParameterHelpers.cs (1)

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

Symbols\Source\SourceMemberContainerSymbol.cs (9)

2068if (symbol.Kind != SymbolKind.Method || lastSym.Kind != SymbolKind.Method) 2079if (lastSym.Kind == SymbolKind.Method) 2715if (member.Kind != SymbolKind.Method || ((MethodSymbol)member).MethodKind != MethodKind.Destructor) 4400if (symbol.Kind != SymbolKind.Method) 4439if (symbol.Kind != SymbolKind.Method) 4600case SymbolKind.Method: 4662case SymbolKind.Method: 5417if (member.Kind == SymbolKind.Method)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (11)

103if (abstractMember.Kind == SymbolKind.Method && abstractMember is not SynthesizedRecordOrdinaryMethod) 142case SymbolKind.Method: 237var associatedPropertyOrEvent = interfaceMemberKind == SymbolKind.Method ? ((MethodSymbol)interfaceMember).AssociatedSymbol : null; 312if (wasImplementingMemberFound && interfaceMemberKind == SymbolKind.Method) 535case SymbolKind.Method: 704if (hiddenMember.Kind == SymbolKind.Method && !((MethodSymbol)hiddenMember).CanBeHiddenByMember(symbol)) 752var overridingMemberIsMethod = overridingMember.Kind == SymbolKind.Method; 871var overridingMemberIsMethod = overridingMember.Kind == SymbolKind.Method; 1662case SymbolKind.Method: 1692case SymbolKind.Method: 1825if ((object)implementingMember == null || implementingMember.Kind != SymbolKind.Method)

Symbols\Source\SourceParameterSymbol.cs (1)

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

Symbols\SubstitutedTypeParameterSymbol.cs (1)

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

Symbols\Symbol.cs (6)

666case SymbolKind.Method: 726if (this.Kind == SymbolKind.Method) 903Debug.Assert(this.Kind == SymbolKind.NamedType || this.Kind == SymbolKind.Method); 1225case SymbolKind.Method: 1666case SymbolKind.Method: 1737case SymbolKind.Method:

Symbols\Symbol_Attributes.cs (3)

54case SymbolKind.Method: 911Debug.Assert(this.Kind == SymbolKind.Method); 932case SymbolKind.Method:

Symbols\SymbolDistinguisher.cs (1)

61case SymbolKind.Method:

Symbols\SymbolExtensions.cs (6)

147while (containingMember is object && containingMember.Kind == SymbolKind.Method) 166case SymbolKind.Method: 207case SymbolKind.Method: 338case SymbolKind.Method: 485case SymbolKind.Method: 534SymbolKind.Method => ((MethodSymbol)symbol).RequiresInstanceReceiver,

Symbols\SymbolKindExtensions.cs (1)

34case SymbolKind.Method:

Symbols\Tuples\TupleTypeSymbol.cs (2)

691case SymbolKind.Method: 1062case SymbolKind.Method:

Symbols\TypeSymbol.cs (11)

750case SymbolKind.Method: 818Debug.Assert(interfaceMember.Kind == SymbolKind.Method || interfaceMember.Kind == SymbolKind.Property || interfaceMember.Kind == SymbolKind.Event); 1020if (!canBeImplementedImplicitlyInCSharp9 && interfaceMember.Kind == SymbolKind.Method && 1522associated = implementation.Kind == SymbolKind.Method 1641if (interfaceMember.Kind == SymbolKind.Method) 1691if (interfaceMember.Kind == SymbolKind.Method) 1958case SymbolKind.Method: 2024case SymbolKind.Method: 2044case SymbolKind.Method: 2308Debug.Assert(interfaceMember.Kind != SymbolKind.Method || (object)interfaceMember == ((MethodSymbol)interfaceMember).ConstructedFrom); 2423case SymbolKind.Method:

Symbols\TypeSymbolExtensions.cs (2)

353return p.ContainingSymbol.Kind == SymbolKind.Method; 1747case SymbolKind.Method:

Symbols\VarianceSafety.cs (1)

49case SymbolKind.Method:

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

442case SymbolKind.Method:

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

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

SymbolKey\SymbolKeyTestBase.cs (2)

171kinds.Add(SymbolKind.Method); 230case SymbolKind.Method:

CodeGen\CodeGenDynamicTests.cs (1)

689case SymbolKind.Method:

CodeGen\CodeGenTupleTest.cs (1)

11629if (members1[i].Kind == SymbolKind.Method)

Attributes\AttributeTests_MarshalAs.cs (1)

70var methods = type.GetMembers().Where(s => s.Kind == SymbolKind.Method);

Attributes\AttributeTests_Security.cs (11)

729ParentKind = SymbolKind.Method, 772ParentKind = SymbolKind.Method, 810ParentKind = SymbolKind.Method, 903ParentKind = SymbolKind.Method, 1015ParentKind = SymbolKind.Method, 1034ParentKind = SymbolKind.Method, 1143ParentKind = SymbolKind.Method, 1162ParentKind = SymbolKind.Method, 1268ParentKind = SymbolKind.Method, 1345ParentKind = SymbolKind.Method, 1444ParentKind = SymbolKind.Method,

Attributes\AttributeTests_Synthesized.cs (1)

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

Attributes\AttributeTests_Tuples.cs (1)

277case SymbolKind.Method:

Diagnostics\DiagnosticAnalyzerTests.cs (9)

516SymbolKind.Namespace, SymbolKind.NamedType, SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.Property); 842}, SymbolKind.Method); 2884TestSymbolStartAnalyzerCore(new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.Method), 2930var analyzer2 = new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.Method, analyzerId: 2); 2956var analyzer2 = new SymbolStartAnalyzer(topLevelAction: false, SymbolKind.Method, analyzerId: 2); 2989var symbolKinds = new[] { SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Method, 3062TestSymbolStartAnalyzerCore(new SymbolStartAnalyzer(topLevelAction: true, SymbolKind.Method, OperationKind.VariableDeclarationGroup), 3083var symbolKinds = new[] { SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Method, 3143var symbolKinds = new[] { SymbolKind.NamedType, SymbolKind.Namespace, SymbolKind.Method,

FlowAnalysis\FlowTestBase.cs (1)

71case SymbolKind.Method:

Semantics\ExtensionTests.cs (2)

43080context.RegisterSymbolAction(handle, SymbolKind.Method); 43178context.RegisterSymbolStartAction(handleStart, SymbolKind.Method);

Semantics\PrimaryConstructorTests.cs (6)

1329Assert.Equal(SymbolKind.Method, symbol.Kind); 4080context.RegisterSymbolAction(Handle, SymbolKind.Method); 4166context.RegisterSymbolStartAction(Handle1, SymbolKind.Method); 5143context.RegisterSymbolAction(Handle1, SymbolKind.Method); 5483context.RegisterSymbolAction(Handle, SymbolKind.Method); 5570context.RegisterSymbolStartAction(Handle1, SymbolKind.Method);

Semantics\RecordTests.cs (4)

21507Assert.Equal(SymbolKind.Method, symbol!.Kind); 26622context.RegisterSymbolAction(Handle, SymbolKind.Method); 26717context.RegisterSymbolStartAction(Handle1, SymbolKind.Method); 27714context.RegisterSymbolAction(Handle1, SymbolKind.Method);

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

644SymbolKind.Method => Glyph.MethodPublic, 677symbolKindOrTypeKind.MethodKind.HasValue ? SymbolKind.Method :

Completion\CompletionProviders\SymbolCompletionProvider.cs (1)

249if (symbol.IsKind(SymbolKind.Method) && !context.IsNameOfContext)

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (1)

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

GenerateType\CSharpGenerateTypeService.cs (2)

431return memberGroup.ElementAt(0).IsKind(SymbolKind.Method) ? (IMethodSymbol)memberGroup.ElementAt(0) : null; 441if (expressionSymbol.IsKind(SymbolKind.Method))

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

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

NavigationBar\CSharpNavigationBarItemService.cs (1)

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

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

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

IOperation\IOperationTests_IVariableDeclaration.cs (1)

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

Semantics\ColorColorTests.cs (27)

Semantics\LambdaTests.cs (2)

856Assert.Equal(SymbolKind.Method, sym.Kind); 866Assert.Equal(SymbolKind.Method, sym.Kind);

Semantics\NativeIntegerTests.cs (4)

324case SymbolKind.Method: 438case SymbolKind.Method: 564case SymbolKind.Method: 617case SymbolKind.Method:

Semantics\RecordStructTests.cs (3)

6255context.RegisterSymbolAction(Handle, SymbolKind.Method); 6351context.RegisterSymbolStartAction(Handle1, SymbolKind.Method); 6889context.RegisterSymbolAction(Handle1, SymbolKind.Method);

Semantics\TopLevelStatementsTests.cs (7)

707Assert.Equal(SymbolKind.Method, local.ContainingSymbol.Kind); 4224Assert.Equal(SymbolKind.Method, local.ContainingSymbol.Kind); 4902Assert.Equal(SymbolKind.Method, label.ContainingSymbol.Kind); 4987Assert.Equal(SymbolKind.Method, label.ContainingSymbol.Kind); 6531context.RegisterSymbolAction(Handle, SymbolKind.Method); 6606context.RegisterSymbolStartAction(Handle1, SymbolKind.Method); 7270context.RegisterSymbolAction(Handle1, SymbolKind.Method);

Semantics\UnsafeTests.cs (1)

5203Assert.Equal(SymbolKind.Method, binder.ContainingMemberOrLambda.Kind);

Compilation\GetSemanticInfoTests.cs (8)

Compilation\IndexedProperties_BindingTests.cs (1)

42IndexedPropertiesBindingChecks(source, reference, SymbolKind.Method, "get_P1");

Compilation\SemanticModelAPITests.cs (9)

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (9)

1391Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "A")); 1392Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "B")); 1393Assert.True(symbolsInC.Any(s => s.Name == "M" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "C")); 1394Assert.True(symbolsInC.Any(s => s.Name == "F" && s.Kind == SymbolKind.Method && s.ContainingType.Name == "C")); 1722symbol.Kind == SymbolKind.Method && (((IMethodSymbol)symbol).IsExtensionMethod || ((IMethodSymbol)symbol).MethodKind == MethodKind.ReducedExtension); 1885symbol.Kind == SymbolKind.Method && (((IMethodSymbol)symbol).IsExtensionMethod || ((IMethodSymbol)symbol).MethodKind == MethodKind.ReducedExtension); 3590Assert.Equal(SymbolKind.Method, symbol.Kind); 3615Assert.Equal(SymbolKind.Method, symbol.Kind); 3849Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind);

Compilation\SemanticModelGetSemanticInfoTests.cs (116)

CrossLanguageTests.cs (1)

38Assert.Empty(t.GetMembersUnordered().Where(x => x.Kind == SymbolKind.Method && !x.CanBeReferencedByName));

DocumentationComments\CrefTests.cs (4)

817Assert.Equal(SymbolKind.Method, GetReferencedSymbol(crefSyntax, compilation).Kind); 864Assert.Equal(SymbolKind.Method, GetReferencedSymbol(crefSyntax, compilation).Kind); 1813Assert.Equal(SymbolKind.Method, actualSymbol.Kind); 6072Assert.Equal(SymbolKind.Method, methodSymbol.Kind);

DocumentationComments\DocumentationCommentIDTests.cs (1)

184Assert.Equal(SymbolKind.Method, symbol.Kind);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (1)

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

Symbols\AnonymousTypesSemanticsTests.cs (4)

591Assert.Equal(SymbolKind.Method, method.Kind); 659Assert.Equal(SymbolKind.Method, method.Kind); 680Assert.Equal(SymbolKind.Method, method.Kind); 701Assert.Equal(SymbolKind.Method, method.Kind);

Symbols\ConversionTests.cs (2)

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

Symbols\ExtensionMethodTests.cs (2)

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

Symbols\Metadata\MetadataMemberTests.cs (3)

163Assert.Equal(SymbolKind.Method, ctor.Kind); 204Assert.Equal(SymbolKind.Method, member1.Kind); 311Assert.Equal(SymbolKind.Method, member1.Kind);

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

111Assert.Equal(SymbolKind.Method, csFields.GetMembers("FfF").Single().Kind);

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

102Assert.Equal(SymbolKind.Method, sameName2.Kind);

Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (1)

85case SymbolKind.Method:

Symbols\Retargeting\RetargetingTests.cs (2)

1179case SymbolKind.Method: 1307case SymbolKind.Method:

Symbols\Source\DeclaringSyntaxNodeTests.cs (2)

523if (memb.Kind == SymbolKind.Method && ((IMethodSymbol)memb).MethodKind == MethodKind.Constructor) 577if (memb.Kind == SymbolKind.Method)

Symbols\Source\MethodTests.cs (1)

449Assert.Equal(SymbolKind.Method, method.Kind);

Symbols\TypeTests.cs (1)

495Assert.Equal(SymbolKind.Method, method.Kind);

CompilationTestUtils.cs (1)

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

EmitMetadataTestBase.cs (1)

151kind = SymbolKind.Method;

Extensions.cs (3)

755case SymbolKind.Method: 816case SymbolKind.Method: 851case SymbolKind.Method:

Metadata\WinMdDumpTest.cs (1)

95case SymbolKind.Method:

Recommendations\CSharpRecommendationServiceRunner.cs (1)

782if (symbol.Kind is SymbolKind.Method &&

Rename\CSharpRenameRewriterLanguageService.cs (3)

842else if (renamedSymbol.Kind == SymbolKind.Method) 958(renameSymbol.Kind == SymbolKind.Method && 1023if (symbol.Kind == SymbolKind.Method)

Simplification\CSharpSimplificationService.Expander.cs (1)

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

85if (symbol.Kind == SymbolKind.Method && name.Kind() == SyntaxKind.GenericName)

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

442case SymbolKind.Method:

Peek\PeekHelpers.cs (1)

59case SymbolKind.Method:

Diagnostics\DiagnosticServiceTests.vb (4)

1260context.RegisterSymbolAction(AddressOf AnalyzeSymbol, SymbolKind.Method) 1894End Sub, SymbolKind.Method) 2461Assert.Equal(SymbolKind.Method, analyzedMethod.Kind) 2525context.RegisterSymbolAction(Sub(symbolContext) AnalyzedMethodSymbols.Add(symbolContext.Symbol), SymbolKind.Method)

DkmUtilities.cs (1)

295case SymbolKind.Method:

Symbols\ISymbolExtensions.cs (2)

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

Symbols\ISymbolExtensions_Accessibility.cs (1)

143case SymbolKind.Method:

Symbols\SignatureComparer.cs (2)

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

Symbols\SymbolEquivalenceComparer.EquivalenceVisitor.cs (1)

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

Symbols\SymbolEquivalenceComparer.GetHashCodeVisitor.cs (1)

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

ChangeSignature\AbstractChangeSignatureService.cs (1)

144if (!symbol.MatchesKind(SymbolKind.Method, SymbolKind.Property))

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

359case SymbolKind.Method:

CodeLens\CodeLensReferencesService.cs (1)

225if (current.Kind != SymbolKind.Method)

Completion\CommonCompletionUtilities.cs (1)

104case SymbolKind.Method:

Completion\Providers\AbstractOverrideCompletionProvider.cs (1)

75SymbolKind.Method => ((IMethodSymbol)symbol).ReturnType,

Completion\Providers\AbstractRecommendationServiceBasedCompletionProvider.cs (1)

191if (symbol.MatchesKind(SymbolKind.Event, SymbolKind.Method))

Debugging\AbstractBreakpointResolver.cs (3)

232SymbolKind.Method => ((IMethodSymbol)symbol).PartialImplementationPart, 245if (kind is not (SymbolKind.Method or SymbolKind.Property)) 272if (methodOrProperty.IsKind(SymbolKind.Method))

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

141case SymbolKind.Method:

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

313SymbolKind.Method => GetDisplayName((IMethodSymbol)symbol), 2509case SymbolKind.Method: 3542=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field or SymbolKind.Event; 4654var rudeEdit = oldSymbol.ContainingSymbol.Kind == SymbolKind.Method ? RudeEditKind.GenericMethodUpdate : RudeEditKind.GenericTypeUpdate;

EditAndContinue\RudeEditReportingCondition.cs (1)

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

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

205SymbolKind.Method or

GoToBase\FindBaseHelpers.cs (1)

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

InlineMethod\AbstractInlineMethodRefactoringProvider.cs (1)

577|| declaredSymbol.IsKind(SymbolKind.Method)

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (2)

35SymbolKind.Method or 48SymbolKind.Method => new WrappedMethodSymbol((IMethodSymbol)m, canImplementImplicitly, docCommentFormattingService),

MetadataAsSource\MetadataAsSourceFileService.cs (1)

290case SymbolKind.Method:

Rename\SymbolicRenameInfo.cs (2)

189symbol.ContainingSymbol.Kind == SymbolKind.Method && 206if (symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).MethodKind == MethodKind.UserDefinedOperator)

SemanticSearch\QueryExecutionContext.cs (1)

209QueryKind.Method => SymbolKind.Method,

Shared\Extensions\ISymbolExtensions_2.cs (1)

95case SymbolKind.Method:

Shared\Extensions\ISymbolExtensions_Sorting.cs (3)

170if (s1.Kind == SymbolKind.Method || s2.Kind == SymbolKind.Method) 174: s1.Kind == SymbolKind.Method ? -1 : 1;

Shared\Utilities\ExtractTypeHelpers.cs (1)

208case SymbolKind.Method:

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

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

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

782case SymbolKind.Method:

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

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

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

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

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

139.Where(m => m.Kind != SymbolKind.Method);

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

DeclarePublicApiAnalyzer.cs (1)

148SymbolKind.Method);

DeclarePublicApiAnalyzer.Impl.cs (1)

304if (symbol.Kind == SymbolKind.Method)

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

Compilation\CompilationExtensions.cs (2)

239if (declaration.DeclaredSymbol.Kind == SymbolKind.Method && compilation.Language == LanguageNames.VisualBasic) 263case SymbolKind.Method:

Diagnostics\CommonDiagnosticAnalyzers.cs (6)

1573if (context.OwningSymbol.Kind != SymbolKind.Method || 1591if (context.OwningSymbol.Kind != SymbolKind.Method || 1606if (context.OwningSymbol.Kind != SymbolKind.Method) 1619if (context.OwningSymbol.Kind != SymbolKind.Method) 2751SymbolKind.NamedType, SymbolKind.Method); 3016context.RegisterSymbolAction(symbolContext => AnalyzedSymbols.Add(symbolContext.Symbol), SymbolKind.NamedType, SymbolKind.Method);

Diagnostics\SuppressMessageAttributeTests.DiagnosticAnalyzers.cs (1)

74SymbolKind.Method,

Diagnostics\TrackingDiagnosticAnalyzer.cs (14)

Analysis\FlowAnalysis\AbstractFlowPass.vb (5)

112_info.Symbol.Kind = SymbolKind.Method OrElse 239Return If(Me.symbol.Kind = SymbolKind.Method, DirectCast(Me.symbol, MethodSymbol).Parameters, ImmutableArray(Of ParameterSymbol).Empty) 253Return Me.symbol.Kind = SymbolKind.Method AndAlso DirectCast(Me.symbol, MethodSymbol).Locations.Length = 1 263Return If(Me.symbol.Kind = SymbolKind.Method, DirectCast(Me.symbol, MethodSymbol), Nothing) 273Return If(Me.symbol.Kind = SymbolKind.Method, DirectCast(Me.symbol, MethodSymbol).ReturnType, Nothing)

Analysis\InitializerRewriter.vb (1)

88If member.Kind = SymbolKind.Method Then

Analysis\IteratorAndAsyncAnalysis\IteratorAndAsyncCaptureWalker.vb (1)

51Debug.Assert(info.Symbol.Kind = SymbolKind.Method)

Binding\Binder.vb (1)

400Case SymbolKind.Method

Binding\Binder_Constraints.vb (2)

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

Binding\Binder_Expressions.vb (12)

1907Case SymbolKind.Method 2237Case SymbolKind.Method, SymbolKind.Property 2585Case SymbolKind.Field, SymbolKind.Method, SymbolKind.Property, SymbolKind.Event 3092((lookupResult.Symbols(0).Kind <> SymbolKind.Method AndAlso lookupResult.Symbols(0).Kind <> SymbolKind.Property) OrElse 3139Case SymbolKind.Method 3516Case SymbolKind.Method 4006Case SymbolKind.Method 4629Return ContainingMember.Kind = SymbolKind.Method AndAlso DirectCast(ContainingMember, MethodSymbol).IsAsync 4633Return ContainingMember.Kind = SymbolKind.Method AndAlso DirectCast(ContainingMember, MethodSymbol).IsIterator 4740If lookupResult.Kind = LookupResultKind.Good AndAlso lookupResult.Symbols(0).Kind = SymbolKind.Method Then 4838If lookupResult.Kind = LookupResultKind.Good AndAlso lookupResult.Symbols(0).Kind = SymbolKind.Method Then 4960ElseIf ContainingMember.Kind = SymbolKind.Method Then

Binding\Binder_Invocation.vb (6)

58If Me.ContainingMember.Kind = SymbolKind.Method AndAlso DirectCast(Me.ContainingMember, MethodSymbol).MethodKind = MethodKind.Constructor Then 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) 3130Case SymbolKind.Method

Binding\Binder_Lookup.vb (7)

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 1155result.Symbols(0).Kind <> SymbolKind.Method) Then 1546FilterSymbolsInLookupResult(lookupResult, SymbolKind.Method, leaveInsteadOfRemoving:=True) 1685lookupResult.Symbols(0).Kind <> SymbolKind.Method Then

Binding\Binder_ObjectInitializer.vb (1)

898Return y.Kind = SymbolKind.Method

Binding\Binder_Statements.vb (8)

Binding\Binder_Utils.vb (1)

862Debug.Assert(Not (container.Kind = SymbolKind.Method AndAlso DirectCast(container, MethodSymbol).MethodKind = MethodKind.DelegateInvoke))

Binding\Binder_XmlLiterals.vb (1)

985Case SymbolKind.Method

Binding\BinderFactory.vb (1)

647(symbol.Kind = SymbolKind.Method) Then

Binding\DocumentationCommentBinder.vb (2)

186Case SymbolKind.Method, SymbolKind.Property 206Case SymbolKind.Method

Binding\DocumentationCommentCrefBinder.vb (4)

119Case SymbolKind.Method 387Case SymbolKind.Method 793Case SymbolKind.Method 850Case SymbolKind.Method

Binding\DocumentationCommentCrefBinder_Compat.vb (2)

210Case SymbolKind.Method 395Case SymbolKind.Method

Binding\DocumentationCommentParamBinder.vb (1)

37Case SymbolKind.Method

Binding\DocumentationCommentTypeParamBinder.vb (1)

44Case SymbolKind.Method

Binding\LookupResult.vb (1)

517Case SymbolKind.Method

Binding\SyntheticBoundTrees\SynthesizedPropertyAccessorBase.vb (1)

145If member.Kind = SymbolKind.Method Then

Compilation\ClsComplianceChecker.vb (8)

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

723Case SymbolKind.Method 782SymbolKind.Method

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

106Case SymbolKind.Method

Compilation\DocumentationComments\DocumentationCommentCompiler.vb (1)

119symbol.Kind = SymbolKind.Method OrElse

Compilation\MethodCompiler.vb (5)

136If symbol.Kind = SymbolKind.Method AndAlso symbol.IsImplicitlyDeclared AndAlso 401If symbol.Kind = SymbolKind.Method Then 663Case SymbolKind.Method 764If member.IsShared OrElse Not member.IsFromCompilation(_compilation) OrElse member.Kind <> SymbolKind.Method Then 868If member.Kind = SymbolKind.Method Then

Compilation\SemanticModel.vb (4)

1213Case SymbolKind.Method, SymbolKind.Field, SymbolKind.Property 1867(result.Kind = SymbolKind.Method AndAlso DirectCast(result, MethodSymbol).MethodKind = MethodKind.Constructor) Then 2855If symbol.Kind = SymbolKind.Method Then 3545Case SymbolKind.Method

Compilation\SyntaxTreeSemanticModel.vb (2)

716Case SymbolKind.Method 1063Case SymbolKind.Method

Compilation\VisualBasicCompilation.vb (1)

1568If (Not lookupResult.IsGoodOrAmbiguous) OrElse lookupResult.Symbols(0).Kind <> SymbolKind.Method Then

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.vb (1)

120ElseIf containingSymbol.Kind = SymbolKind.Method Then

Emit\EditAndContinue\PEDeltaAssemblyBuilder.vb (1)

213Debug.Assert(members.Length = 1 AndAlso members(0).Kind = SymbolKind.Method)

Emit\EditAndContinue\VisualBasicSymbolMatcher.vb (1)

336Case SymbolKind.Method

Emit\NamedTypeSymbolAdapter.vb (3)

283If member.Kind = SymbolKind.Method Then 477If member.Kind = SymbolKind.Method Then 981If member.Kind = SymbolKind.Method Then

Emit\NoPia\EmbeddedEvent.vb (1)

113If m.Kind = SymbolKind.Method Then

Emit\NoPia\EmbeddedType.vb (1)

237Case SymbolKind.Method

Emit\PEModuleBuilder.vb (1)

236Case SymbolKind.Method

Emit\SymbolTranslator.vb (1)

460Return container.Kind = SymbolKind.Method AndAlso (DirectCast(container, MethodSymbol)).IsGenericMethod OrElse

Emit\TypeParameterSymbolAdapter.vb (4)

63If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.Method Then 74If AdaptedTypeParameterSymbol.ContainingSymbol.Kind = SymbolKind.Method Then 150If kind = SymbolKind.Method Then 160If kind = SymbolKind.Method Then

Lowering\AsyncRewriter\AsyncRewriter.vb (1)

554If result.Symbols(0).Kind = SymbolKind.Method Then

Lowering\Instrumentation\CodeCoverageInstrumenter.vb (1)

146If nonLambda?.Kind = SymbolKind.Method Then

Lowering\LambdaRewriter\LambdaRewriter.Analysis.vb (1)

255local.ContainingSymbol.Kind <> SymbolKind.Method,

Lowering\LocalRewriter\LocalRewriter_AssignmentOperator.vb (1)

201(fromMember.Kind = SymbolKind.Field OrElse (fromMember.Kind = SymbolKind.Method AndAlso

Semantics\AccessCheck.vb (1)

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

Semantics\Operators.vb (1)

2918If member.Kind = SymbolKind.Method Then

Semantics\OverloadResolution.vb (2)

3252If candidateSymbol.Kind = SymbolKind.Method Then 5221If paramForGenericityCheck.ContainingSymbol.Kind = SymbolKind.Method Then

SymbolDisplay\SymbolDisplayVisitor.Members.vb (1)

700symbol.Kind <> SymbolKind.Method OrElse

Symbols\Attributes\AttributeData.vb (4)

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

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

223Case SymbolKind.Method 286Case SymbolKind.Method 309symbol.Kind = SymbolKind.Method OrElse 342Case SymbolKind.Method

Symbols\MemberSignatureComparer.vb (3)

55Case SymbolKind.Method 72Case SymbolKind.Method 87Case SymbolKind.Method, SymbolKind.Property, SymbolKind.Event

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

548If m.Kind <> SymbolKind.Method Then

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

530Dim index = GetIndexOfFirstMember(members, SymbolKind.Method) 535If member.Kind <> SymbolKind.Method Then 551If index >= members.Length OrElse members(index).Kind <> SymbolKind.Method Then 572If index = members.Length OrElse members(index).Kind <> SymbolKind.Method Then 633Case SymbolKind.Method

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

490Return SymbolKind.Method

Symbols\NamedTypeSymbol.vb (3)

308If member.Kind = SymbolKind.Method Then 420If candidate.Kind = SymbolKind.Method Then 428If candidate.Kind = SymbolKind.Method Then

Symbols\NamedTypeSymbolExtensions.vb (1)

36If kind = SymbolKind.Method Then

Symbols\NamespaceOrTypeSymbol.vb (1)

203If member.Kind = SymbolKind.Method Then

Symbols\NamespaceSymbol.vb (2)

498If member.Kind = SymbolKind.Method Then 519If member.Kind = SymbolKind.Method Then

Symbols\PropertySymbol.vb (1)

215((fromMember.Kind = SymbolKind.Method AndAlso DirectCast(fromMember, MethodSymbol).IsAnyConstructor) OrElse

Symbols\Retargeting\RetargetingSymbolTranslator.vb (4)

68Dim containingType = If(container.Kind = SymbolKind.Method, 791If underlyingSymbol.Kind = SymbolKind.Method Then 797Debug.Assert(underlyingSymbol.Kind = SymbolKind.Method) 984If retargetedMember.Kind = SymbolKind.Method Then

Symbols\Source\ImplementsHelper.vb (3)

26Case SymbolKind.Method 101If implementingSym.Kind = SymbolKind.Method Then 428Case SymbolKind.Method

Symbols\Source\LambdaSymbol.vb (2)

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

Symbols\Source\LocalSymbol.vb (2)

105Debug.Assert(container.Kind = SymbolKind.Method OrElse 155Debug.Assert((Me.IsFunctionValue AndAlso _container.Kind = SymbolKind.Method AndAlso DirectCast(_container, MethodSymbol).MethodKind = MethodKind.LambdaMethod) OrElse type.Equals(ComputeType()))

Symbols\Source\OverloadingHelper.vb (1)

29Debug.Assert(kind = SymbolKind.Method OrElse kind = SymbolKind.Property)

Symbols\Source\OverrideHidingHelper.vb (7)

149Case SymbolKind.Method 283Case SymbolKind.Method 284If hidingMember.IsOverloads AndAlso hiddenMember.Kind = SymbolKind.Method Then 358(member.Kind = SymbolKind.Method AndAlso DirectCast(member, MethodSymbol).IsUserDefinedOperator() <> DirectCast(hiddenMember, MethodSymbol).IsUserDefinedOperator()) OrElse 433(hidingMember.Kind = SymbolKind.Property OrElse hidingMember.Kind = SymbolKind.Method) AndAlso 492If sym.Kind <> SymbolKind.Method Then 513Case SymbolKind.Method

Symbols\Source\SourceDeclareMethodSymbol.vb (1)

59OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Method, m_containingType)

Symbols\Source\SourceMemberContainerTypeSymbol.vb (12)

444Case SymbolKind.Method 1152haveExtensionMethods = (sym.Kind = SymbolKind.Method AndAlso DirectCast(sym, MethodSymbol).IsExtensionMethod) 2407Case SymbolKind.Method 2443If (symbol.Kind = SymbolKind.Method AndAlso checkMethods) OrElse (symbol.IsPropertyAndNotWithEvents AndAlso checkProperties) Then 2466Case SymbolKind.Method 2777Debug.Assert(symbols.Where(Function(sym) sym.Kind = SymbolKind.Method AndAlso 3101ElseIf ((firstSymbol.Kind <> SymbolKind.Method) AndAlso (Not firstSymbol.IsPropertyAndNotWithEvents)) OrElse 3522For Each memberKind In {SymbolKind.Method, SymbolKind.Property} 3531If canDeclareOperators AndAlso memberKind = SymbolKind.Method AndAlso 3589If canDeclareOperators AndAlso memberKind = SymbolKind.Method AndAlso 3611If member.Kind <> SymbolKind.Method Then 3739If nextMember.Kind <> SymbolKind.Method Then

Symbols\Source\SourceMemberMethodSymbol.vb (1)

109OverloadingHelper.SetMetadataNameForAllOverloads(_name, SymbolKind.Method, m_containingType)

Symbols\Source\SourceMethodSymbol.vb (1)

1137SymbolKind.Method, GetMethodLocationFromSyntax(syntax), tree), MethodSymbol)

Symbols\Source\SourceNamedTypeSymbol.vb (1)

2681If member.Kind = SymbolKind.Method Then

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (6)

103If m.Kind = SymbolKind.Method Then 382Case SymbolKind.Method 452Case SymbolKind.Method 547Case SymbolKind.Method 1338If attributeSource.Kind = SymbolKind.Method Then 1379If attributeSource.Kind = SymbolKind.Method Then

Symbols\Source\SourceParameterSymbol.vb (4)

186If containingSymbol.Kind = SymbolKind.Method AndAlso DirectCast(containingSymbol, MethodSymbol).MethodKind = MethodKind.DeclareMethod Then 206Case SymbolKind.Method 450If container.Kind = SymbolKind.Method Then 495ContainingSymbol.Kind = SymbolKind.Method AndAlso

Symbols\SubstitutedNamedType.vb (2)

371Case SymbolKind.Method 454Case SymbolKind.Method

Symbols\SubstitutedTypeParameterSymbol.vb (1)

89Return If(_containingSymbol.Kind = SymbolKind.Method,

Symbols\Symbol.vb (3)

617Case SymbolKind.Method 657If Me.Kind = SymbolKind.Method Then 1000Case SymbolKind.Method

Symbols\Symbol_Attributes.vb (4)

71Case SymbolKind.Method 520Debug.Assert(Me.Kind = SymbolKind.Method OrElse Me.Kind = SymbolKind.Property) 546If Me.Kind = SymbolKind.Method Then 588Case SymbolKind.Assembly, SymbolKind.NamedType, SymbolKind.Method

Symbols\SymbolExtensions.vb (14)

Symbols\Tuples\TupleTypeSymbol.vb (2)

714Case SymbolKind.Method 914Case SymbolKind.Method

Symbols\TypeSubstitution.vb (5)

563(targetGenericDefinition.Kind = SymbolKind.Method AndAlso 566Debug.Assert((targetGenericDefinition.Kind = SymbolKind.Method AndAlso 596If memberDefinition.Kind = SymbolKind.Method Then 758If targetGenericDefinition.Kind = SymbolKind.Method Then 814If targetGenericDefinition.Kind = SymbolKind.Method Then

Symbols\TypeSymbol.vb (1)

686Case SymbolKind.Method

Symbols\WellKnownMembers.vb (5)

434targetSymbolKind = SymbolKind.Method 439targetSymbolKind = SymbolKind.Method 442targetSymbolKind = SymbolKind.Method 467Case SymbolKind.Method 656If typeParam.ContainingSymbol.Kind <> SymbolKind.Method Then

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

454SymbolKind.Method,

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

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

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

206If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event) Then

Attributes\AttributeTests_MarshalAs.vb (1)

43Dim methods = typeSym.GetMembers().Where(Function(s) s.Kind = SymbolKind.Method)

Attributes\AttributeTests_Tuples.vb (2)

250Case SymbolKind.Method 265Case SymbolKind.Method

CodeGen\CodeGenAsyncTests.vb (1)

9267Case SymbolKind.Method

CodeGen\CodeGenTuples.vb (1)

15210If members1(i).Kind = SymbolKind.Method Then

CodeGen\CodeGenVBCore.vb (1)

3041Case SymbolKind.Method

Emit\CompilationEmitTests.vb (8)

2579Case SymbolKind.Method 2725.ParentKind = SymbolKind.Method, 2832.ParentKind = SymbolKind.Method, 2957.ParentKind = SymbolKind.Method, 2975.ParentKind = SymbolKind.Method, 3029.ParentKind = SymbolKind.Method, 3047.ParentKind = SymbolKind.Method, 3216.ParentKind = SymbolKind.Method,

Symbols\EETypeParameterSymbol.vb (1)

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

CodeRefactorings\InlineTemporary\VisualBasicInlineTemporaryCodeRefactoringProvider.vb (1)

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

Completion\CompletionProviders\CrefCompletionProvider.vb (1)

241ElseIf symbol.Kind = SymbolKind.Method Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (2)

1983Case SymbolKind.Method 2018Case SymbolKind.Method

ExtractMethod\Extensions.vb (1)

140Dim methodSymbols = model.GetSymbolInfo(invocation, cancellationToken).GetAllSymbols().Where(Function(s) s.Kind = SymbolKind.Method).Cast(Of IMethodSymbol)()

GenerateType\VisualBasicGenerateTypeService.vb (2)

330If symbol IsNot Nothing AndAlso symbol.IsKind(SymbolKind.Method) Then 358Return If(memberGroup.ElementAt(0).IsKind(SymbolKind.Method), DirectCast(memberGroup.ElementAt(0), IMethodSymbol), Nothing)

LanguageServices\VisualBasicSymbolDisplayService.SymbolDescriptionBuilder.vb (1)

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

NavigationBar\VisualBasicNavigationBarItemService.vb (1)

269If symbol.Kind = SymbolKind.Method Then

Binding\ImplicitVariableTests.vb (3)

891symbolKind:=SymbolKind.Method) 913symbolKind:=SymbolKind.Method, 927symbolKind:=SymbolKind.Method,

Compilation\MyTemplateTests.vb (1)

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

Compilation\SemanticModelAPITests.vb (5)

502Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind) 511Assert.Equal(SymbolKind.Method, speculativeSymbolInfo.Symbol.Kind) 1054Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind) 1094Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind) 1918speculatedMemberName, SpeculativeBindingOption.BindAsExpression, SymbolKind.Method, "I.Method2")

DeclaringSyntaxNodeTests.vb (2)

510If memb.Kind = SymbolKind.Method AndAlso (DirectCast(memb, MethodSymbol)).MethodKind = MethodKind.Constructor Then 593If memb.Kind = SymbolKind.Method Then

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

36Case SymbolKind.Method

Semantics\BinaryOperators.vb (1)

1103If m.Kind = SymbolKind.Method Then

Semantics\GetExtendedSemanticInfoTests.vb (89)

Semantics\GetSemanticInfoTests.vb (11)

Semantics\NewOnInterfaceTests.vb (1)

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

Semantics\QueryExpressions_SemanticModel.vb (1)

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

Semantics\SelectCaseTests.vb (7)

143Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind) 180Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind) 214Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind) 288Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind) 328Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind) 367Assert.Equal(SymbolKind.Method, sortedCandidates(0).Kind) 497Assert.Equal(SymbolKind.Method, semanticSummary.Symbol.Kind)

Semantics\SyncLockTests.vb (1)

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

Semantics\UsingStatementTest.vb (1)

342If (type.Symbol.Kind = SymbolKind.Method) Then

Semantics\WithBlockSemanticModelTests.vb (1)

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

DocumentationComments\DocCommentTests.vb (5)

6689SymbolKind.Method), 6703SymbolKind.Method)) 6709SymbolKind.Method), 6955Assert.Equal(SymbolKind.Method, method.Kind) 7405container:=DirectCast(symInteger(0), NamedTypeSymbol)), SymbolKind.Method),

SymbolsTests\Metadata\MetadataMemberTests.vb (4)

165Assert.Equal(SymbolKind.Method, ctor.Kind) 210Assert.Equal(SymbolKind.Method, member1.Kind) 326Assert.Equal(SymbolKind.Method, member1.Kind) 725Dim mems = tsym.GetMembers().Where(Function(s) s.Kind = SymbolKind.Method)

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

91Assert.Equal(SymbolKind.Method, sameName(0).Kind)

SymbolsTests\Source\ComClassTests.vb (1)

60Case SymbolKind.Method

SymbolsTests\Source\GroupClassTests.vb (1)

3358Assert.Equal(SymbolKind.Method, symbolInfo.Symbol.Kind)

SymbolsTests\Source\OverridesTests.vb (4)

2476Where memb.Kind = SymbolKind.Method 2479Where memb.Kind = SymbolKind.Method 2482Where memb.Kind = SymbolKind.Method 2485Where memb.Kind = SymbolKind.Method

SymbolsTests\Source\TypeTests.vb (4)

564Dim ctor = enumMembers.Where(Function(s) s.Kind = SymbolKind.Method) 566Assert.Equal(SymbolKind.Method, ctor(0).Kind) 743Assert.Equal(SymbolKind.Method, mem2.Kind) 753Assert.Equal(SymbolKind.Method, mem3.Kind)

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

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

Classification\SyntaxClassification\NameSyntaxClassifier.vb (1)

109Case SymbolKind.Method

Recommendations\VisualBasicRecommendationServiceRunner.vb (1)

343symbols = symbols.WhereAsArray(Function(s) s.Kind <> SymbolKind.Method OrElse DirectCast(s, IMethodSymbol).MethodKind <> MethodKind.UserDefinedOperator)

Rename\VisualBasicRenameRewriterLanguageService.vb (4)

719renamedSymbol.ContainingSymbol.Kind = SymbolKind.Method Then 765ElseIf renamedSymbol.Kind = SymbolKind.Method Then 816(renameSymbol.Kind = SymbolKind.Method AndAlso 950If symbol.Kind = SymbolKind.Method Then

Simplification\Reducers\VisualBasicEscapingReducer.vb (1)

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

Simplification\Reducers\VisualBasicExtensionMethodReducer.vb (2)

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

Simplification\Simplifiers\NameSimplifier.vb (2)

41If symbol.Kind = SymbolKind.Method AndAlso symbol.IsConstructor() Then 45If symbol.Kind = SymbolKind.Method AndAlso name.Kind = SyntaxKind.GenericName Then

Simplification\VisualBasicSimplificationService.Expander.vb (2)

644If symbol.Kind = SymbolKind.Method OrElse 685If newNode.Kind = SyntaxKind.IdentifierName AndAlso symbol.Kind = SymbolKind.Method Then

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

454SymbolKind.Method,

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

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

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

206If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event) Then

Editing\SyntaxGenerator.cs (3)

527var invoke = symbol.Type.GetMembers("Invoke").FirstOrDefault(m => m.Kind == SymbolKind.Method) as IMethodSymbol; 732case SymbolKind.Method: 829case SymbolKind.Method:

FindSymbols\Declarations\DeclarationFinder.cs (1)

120return symbol.Kind is SymbolKind.Method or

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

715case SymbolKind.Method:

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

36SymbolKind.Method => true,

FindSymbols\SymbolFinder_Callers.cs (1)

82SymbolKind.Method or

Recommendations\AbstractRecommendationService.cs (1)

82case SymbolKind.Method:

Rename\ConflictEngine\ConflictResolver.cs (4)

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

Rename\RenameUtilities.cs (1)

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

Shared\Extensions\ISymbolExtensions.cs (1)

279case SymbolKind.Method:

Shared\Extensions\ITypeSymbolExtensions.cs (1)

50not SymbolKind.Method and

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

FindReferencesTests.cs (3)

548var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 581var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 623var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method);

Analyzers\MembersMustExistAnalyzer.cs (1)

62context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method, SymbolKind.Event);

Analyzers\PinvokeAnalyzer.cs (1)

32obj.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);

Parser.cs (1)

201.Where(m => m.Kind == SymbolKind.Method)

Parsing\Parser.TagProvider.cs (1)

88var methodSymbols = providerType.GetMembers(providerMethodName).Where(m => m.Kind == SymbolKind.Method).Cast<IMethodSymbol>();

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

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

63context.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, libraryImportAttrType, env), SymbolKind.Method);

Analyzers\ShapeBreakingDiagnosticSuppressor.cs (1)

38if (diagnosedSymbol.Kind != SymbolKind.Method)

InvocationParser.cs (1)

69 || methodSymbol.Kind != SymbolKind.Method

Code\RelaxTestNamingTest.cs (1)

116context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);

BestFriendOnPublicDeclarationsAnalyzer.cs (1)

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

CallHierarchy\CallHierarchyProvider.cs (2)

57if (symbol.Kind is SymbolKind.Method or 104SymbolKind.Method)

Implementation\ContainedLanguageRefactorNotifyService.cs (1)

83SymbolKind.Method or

Library\ClassView\AbstractSyncClassViewCommandHandler.cs (1)

91SymbolKind.Method or

Library\ObjectBrowser\AbstractDescriptionBuilder.cs (2)

206case SymbolKind.Method: 444|| symbol.Kind is SymbolKind.Method or SymbolKind.Property;

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

38case SymbolKind.Method:

Library\VsNavInfo\NavInfoFactory.cs (1)

51SymbolKind.Method or

Venus\ContainedLanguageCodeSupport.cs (4)

371if (member.Kind != SymbolKind.Method) 403return member.Kind == SymbolKind.Method; 447if (member.Kind == SymbolKind.Method) 464var members = type.GetMembers(memberName).Where(m => m.Kind == SymbolKind.Method);

CodeModel\CSharpCodeModelService.cs (2)

2990case SymbolKind.Method: 3604symbol == null || symbol.Kind != SymbolKind.Method)

CodeModel\CSharpCodeModelService_Prototype.cs (1)

31case SymbolKind.Method:

GlyphExtensionsTests.cs (6)

40SymbolKind.Method, 44SymbolKind.Method, 153SymbolKind.Method, 162SymbolKind.Method, 177SymbolKind kind = SymbolKind.Method, 224if (kind == SymbolKind.Method)

ExtractInterface\ExtractInterfaceViewModelTests.vb (1)

249Assert.Equal("M(string?, IEnumerable<string?>)", viewModel.MemberContainers.Single(Function(c) c.Symbol.IsKind(SymbolKind.Method)).SymbolName)

CodeModel\VisualBasicCodeModelService.vb (1)

3616Case SymbolKind.Method,

CodeModel\VisualBasicCodeModelService_Prototype.vb (2)

38Case SymbolKind.Method 92If symbol.Kind = SymbolKind.Method Then

Venus\ContainedLanguageStaticEventBinding.vb (1)

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

AbstractDoNotCopyValue.cs (2)

159SymbolKind.Method, 1529case SymbolKind.Method:

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method:

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

108invocationSymbol.Kind == SymbolKind.Method)

RelaxTestNamingSuppressorTests.cs (1)

117context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);

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

442case SymbolKind.Method:

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

454SymbolKind.Method,

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

206If symbol.IsKind(SymbolKind.Method) OrElse symbol.IsKind(SymbolKind.Property) OrElse symbol.IsKind(SymbolKind.Event) Then

GenerateFilteredReferenceAssembliesTask.cs (1)

353SymbolKind.Method => SymbolKindFlags.Method,

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (1)

186}, SymbolKind.Method);

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

IdentifiersShouldBeSpelledCorrectly.cs (5)

255SymbolKind.Method, 492SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field 497SymbolKind.TypeParameter => symbol.ContainingSymbol.Kind == SymbolKind.Method 512SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field 517SymbolKind.TypeParameter => symbol.ContainingSymbol.Kind == SymbolKind.Method

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

39SymbolKind.Method or 273SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 311SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

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

59members = members.Where(m => m.Kind != SymbolKind.Method || ((IMethodSymbol)m).AssociatedSymbol == null);

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

414SymbolKind.Method => ((IMethodSymbol)member).Parameters,

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

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

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

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

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

163'M' => SymbolKind.Method, 273case SymbolKind.Method:

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

16[SymbolKind.Method, SymbolKind.Property, SymbolKind.Event];

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

166case SymbolKind.Method: 427CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 507if (Modifiers.HasFlag(Modifiers.Async) && kind == SymbolKind.Method && ((IMethodSymbol)symbol).IsAsync)

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

48SymbolKind.Method => QualifyMethodAccess,

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

757&& symbol.IsKind(SymbolKind.Method) 1055return receiverSymbol.IsKind(SymbolKind.Method) || 1062if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

151if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 353SymbolKind.Method => ((IMethodSymbol)symbol).Arity,

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

143case SymbolKind.Method:

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

43SymbolKind.Method => HaveSameSignature((IMethodSymbol)symbol1, (IMethodSymbol)symbol2, caseSensitive), 161case SymbolKind.Method:

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

124SymbolKind.Method => MethodsAreEquivalent((IMethodSymbol)x, (IMethodSymbol)y, equivalentTypesWithDifferingAssemblies),

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

68SymbolKind.Method => CombineHashCodes((IMethodSymbol)x, currentHash),

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

74public override SymbolKind Kind => SymbolKind.Method;

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

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

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

28case SymbolKind.Method: