Method

Options\SymbolNamesWithValueOptionTests.cs (1)

236Assert.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

158}, SymbolKind.Method);

RequiresAnalyzerBase.cs (1)

69}, 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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

176if (synthesizedSymbol.Kind == SymbolKind.Method) 202if (synthesizedSymbol.Kind == SymbolKind.Method) 418if (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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

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

Binder\Binder.ValueChecks.cs (1)

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

Binder\Binder_AnonymousTypes.cs (1)

193case SymbolKind.Method:

Binder\Binder_Await.cs (1)

172case SymbolKind.Method:

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Crefs.cs (5)

486symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 827if (s.Kind != SymbolKind.Method) 850s.Kind != SymbolKind.Method || ((MethodSymbol)s).Arity == 0); 956case SymbolKind.Method: 1098if (symbol.Kind == SymbolKind.Method)

Binder\Binder_Expressions.cs (11)

Binder\Binder_Lookup.cs (7)

969if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1006if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1356return symbol.Kind == SymbolKind.Method || symbol.IsIndexer(); 1781case SymbolKind.Method: 1802case SymbolKind.Method: 1824case SymbolKind.Method: 1862case SymbolKind.Method:

Binder\Binder_Statements.cs (3)

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

Binder\Binder_Symbols.cs (1)

1447case 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: 4780case 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)

219case SymbolKind.Method:

BoundTree\BoundTreeRewriter.cs (1)

142case SymbolKind.Method:

Compilation\CSharpCompilation.cs (1)

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

2470case SymbolKind.Method: 2490case SymbolKind.Method: 2526case SymbolKind.Method: 2572case SymbolKind.Method:

Compiler\ClsComplianceChecker.cs (11)

Compiler\DocumentationCommentCompiler.cs (3)

143symbol.Kind == SymbolKind.Method || 764case SymbolKind.Method: 780case 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)

525case SymbolKind.Method:

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

Emitter\EditAndContinue\CSharpSymbolMatcher.cs (1)

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

Emitter\Model\NamedTypeSymbolAdapter.cs (2)

328if (member.Kind == SymbolKind.Method) 1044if (m.Kind == SymbolKind.Method)

Emitter\Model\PEModuleBuilder.cs (2)

391case SymbolKind.Method: 1430return 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)

1165case SymbolKind.Method: 7703case SymbolKind.Method: 8757if (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)

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

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

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

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

263targetSymbolKind = SymbolKind.Method; 270targetSymbolKind = SymbolKind.Method; 274targetSymbolKind = SymbolKind.Method; 305case SymbolKind.Method: 1206if (typeParam.ContainingSymbol.Kind != SymbolKind.Method)

Symbols\ExtendedErrorTypeSymbol.cs (1)

319case SymbolKind.Method:

Symbols\MemberSignatureComparer.cs (2)

832case SymbolKind.Method: 844return member.Kind == SymbolKind.Method && ((MethodSymbol)member).IsVararg;

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

1307int index = GetIndexOfFirstMember(members, SymbolKind.Method); 1313if (members[index].Kind != SymbolKind.Method) 1331if (index >= members.Length || members[index].Kind != SymbolKind.Method) 1359if (index == members.Length || members[index].Kind != SymbolKind.Method) 1521Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder()); 1522Debug.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)

646return 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 (10)

1418if (member.Kind != SymbolKind.Method && this.ContainingType is { } containingType) 2107if (symbol.Kind != SymbolKind.Method || lastSym.Kind != SymbolKind.Method) 2118if (lastSym.Kind == SymbolKind.Method) 2705if (member.Kind != SymbolKind.Method || ((MethodSymbol)member).MethodKind != MethodKind.Destructor) 4372if (symbol.Kind != SymbolKind.Method) 4411if (symbol.Kind != SymbolKind.Method) 4572case SymbolKind.Method: 4634case SymbolKind.Method: 5389if (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: 1671case SymbolKind.Method: 1742case 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: 2309Debug.Assert(interfaceMember.Kind != SymbolKind.Method || (object)interfaceMember == ((MethodSymbol)interfaceMember).ConstructedFrom); 2424case 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)

51435context.RegisterSymbolAction(handle, SymbolKind.Method); 51533context.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)

651SymbolKind.Method => Glyph.MethodPublic, 684symbolKindOrTypeKind.MethodKind.HasValue ? SymbolKind.Method :

Completion\CompletionProviders\SymbolCompletionProvider.cs (1)

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

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (1)

1008return 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 { ContainingSymbol.Kind: SymbolKind.Method } 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); 6585context.RegisterSymbolAction(Handle, SymbolKind.Method); 6660context.RegisterSymbolStartAction(Handle1, SymbolKind.Method); 7324context.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)

787if (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:

DkmUtilities.cs (1)

295case SymbolKind.Method:

Symbols\ISymbolExtensions.cs (2)

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

363case SymbolKind.Method:

CodeLens\CodeLensReferencesService.cs (1)

353if (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), 2648case SymbolKind.Method: 3704=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field or SymbolKind.Event; 4840var 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)

301case SymbolKind.Method:

Rename\SymbolicRenameInfo.cs (2)

190symbol.ContainingSymbol.Kind == SymbolKind.Method && 207if (symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).MethodKind == MethodKind.UserDefinedOperator)

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

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

147SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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) 2754SymbolKind.NamedType, SymbolKind.Method); 3019context.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)

352Case SymbolKind.Method

Emit\NamedTypeSymbolAdapter.vb (3)

289If member.Kind = SymbolKind.Method Then 483If member.Kind = SymbolKind.Method Then 987If 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

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

247.Where(s => !s.MatchesKind(SymbolKind.Method, SymbolKind.Property) || 248!renamedSymbol.MatchesKind(SymbolKind.Method, SymbolKind.Property)); 253.Where(s => s.Kind != SymbolKind.Method || renamedSymbol.Kind != SymbolKind.Method);

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

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

578var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 613var constructorResult = result.Single(r => r.Definition.Kind == SymbolKind.Method); 657var 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)

56if (symbol.Kind is SymbolKind.Method or 103SymbolKind.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, 152SymbolKind.Method, 159SymbolKind.Method, 171SymbolKind kind = SymbolKind.Method, 218if (kind == SymbolKind.Method)

CodeModel\AbstractCodeModelObject_CodeGen.cs (2)

41accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Method, destination), 150accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Method, destination),

CodeModel\AbstractCodeModelService.cs (1)

215case SymbolKind.Method:

CodeModel\Collections\ExternalOverloadsCollection.cs (1)

62if (method.Kind != SymbolKind.Method)

CodeModel\Collections\OverloadsCollection.cs (1)

66if (method.Kind != SymbolKind.Method)

CodeModel\ExternalElements\ExternalCodeFunction.cs (1)

80.Where(m => m.Kind == SymbolKind.Method);

CodeModel\InternalElements\CodeFunction.cs (1)

129.Where(m => m.Kind == SymbolKind.Method);

CodeModel\MethodXml\AbstractMethodXmlBuilder.cs (1)

355case 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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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:

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

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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)

256SymbolKind.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\Extensions\SymbolUsageInfo.cs (1)

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

758&& symbol.IsKind(SymbolKind.Method) 1056return receiverSymbol.IsKind(SymbolKind.Method) || 1063if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

153if (symbol.Kind is not SymbolKind.Method and not SymbolKind.Property and not SymbolKind.Event) 356SymbolKind.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: