Method

AspireExportAnalyzer.cs (1)

164SymbolKind.Method);

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

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

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

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

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

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

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

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

74public override SymbolKind Kind => SymbolKind.Method;

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

28case SymbolKind.Method:

DataFlow\DynamicallyAccessedMembersBinder.cs (1)

462case SymbolKind.Method:

DynamicallyAccessedMembersAnalyzer.cs (1)

167}, SymbolKind.Method);

RequiresAnalyzerBase.cs (1)

98}, SymbolKind.Method);

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,

JSInvokableAnalyzer.cs (1)

62}, SymbolKind.Method);

InternalUsageAnalyzer.cs (1)

54SymbolKind.Method,

AttributesShouldNotBeAppliedToPageModelAnalyzer.cs (1)

53}, SymbolKind.Method);

TopLevelParameterNameAnalyzer.cs (1)

81}, SymbolKind.Method);

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)

1319case SymbolKind.Method:

DiagnosticAnalyzer\DiagnosticStartAnalysisScope.cs (2)

554case SymbolKind.Method: 593ImmutableArray.Create(SymbolKind.Method, SymbolKind.Property, SymbolKind.NamedType));

DocumentationCommentId.cs (2)

776kind = SymbolKind.Method; 867case 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\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

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

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

75SymbolKind.Method,

src\roslyn\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\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

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

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

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

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

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

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

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

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

74public override SymbolKind Kind => SymbolKind.Method;

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

28case SymbolKind.Method:

src\66dd3055a1c91c38\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (1)

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

src\683181b2796de991\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

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

src\roslyn\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\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

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

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

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

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

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

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

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

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

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

src\roslyn\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\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

782case SymbolKind.Method:

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

229compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 947case SymbolKind.Method:

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

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

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

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

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

74public override SymbolKind Kind => SymbolKind.Method;

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

28case SymbolKind.Method:

Binder\Binder_AnonymousTypes.cs (1)

193case SymbolKind.Method:

Binder\Binder_Await.cs (1)

173case SymbolKind.Method:

Binder\Binder_Constraints.cs (1)

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

Binder\Binder_Crefs.cs (5)

508symbol.Kind != SymbolKind.Method || TypeSymbol.Equals(((MethodSymbol)symbol).ReturnType, returnType, TypeCompareKind.ConsiderEverything2), returnType); 849if (s.Kind != SymbolKind.Method) 872s.Kind != SymbolKind.Method || ((MethodSymbol)s).Arity == 0); 980case SymbolKind.Method: 1122if (symbol.Kind == SymbolKind.Method)

Binder\Binder_Expressions.cs (11)

Binder\Binder_Lookup.cs (7)

1005if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1042if (sym.Kind == SymbolKind.Method || sym.Kind == SymbolKind.Property) 1392return symbol.Kind == SymbolKind.Method || symbol.IsIndexer(); 1817case SymbolKind.Method: 1838case SymbolKind.Method: 1860case SymbolKind.Method: 1898case SymbolKind.Method:

Binder\Binder_Statements.cs (3)

3019return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningTask(this.Compilation); 3025return symbol?.Kind == SymbolKind.Method && ((MethodSymbol)symbol).IsAsyncEffectivelyReturningGenericTask(this.Compilation); 3031if (symbol?.Kind == SymbolKind.Method)

Binder\Binder_Symbols.cs (1)

1462case SymbolKind.Method:

Binder\Binder_Unsafe.cs (1)

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

Binder\Binder.cs (4)

484case SymbolKind.Method: 647case SymbolKind.Method: 684symbol.Kind == SymbolKind.Method || 690if (symbol.Kind == SymbolKind.Method)

Binder\Binder.IdentifierUsedAsValueFinder.cs (1)

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

Binder\Binder.ValueChecks.cs (1)

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

Binder\BinderFactory.BinderFactoryVisitor.cs (3)

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

Binder\ContextualAttributeBinder.cs (1)

58case SymbolKind.Method:

Binder\ForEachLoopBinder.cs (1)

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

Binder\InMethodBinder.cs (2)

262case SymbolKind.Method: 298case 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)

1470case SymbolKind.Method: 4789case SymbolKind.Method:

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

800if (inferenceFailed.Member.Kind == SymbolKind.Method) 938Debug.Assert(badMember.Kind == SymbolKind.Method);

Binder\WithLambdaParametersBinder.cs (1)

139case SymbolKind.Method:

Binder\WithUsingNamespacesAndTypesBinder.cs (1)

158case SymbolKind.Method:

BoundTree\BoundTreeRewriter.cs (1)

142case SymbolKind.Method:

Compilation\CSharpCompilation.cs (1)

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

Compilation\CSharpSemanticModel.cs (4)

3763case SymbolKind.Method: 3789case SymbolKind.Method: 4547case SymbolKind.Method: 4617if (((object)otherSymbol != null) && (otherSymbol.Kind == SymbolKind.Method))

Compilation\MethodBodySemanticModel.cs (1)

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

Compilation\SyntaxTreeSemanticModel.cs (4)

2483case SymbolKind.Method: 2503case SymbolKind.Method: 2539case SymbolKind.Method: 2585case 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)

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

Compiler\MethodCompiler.cs (1)

525case SymbolKind.Method:

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

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

398case SymbolKind.Method: 1583return 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)

1760while (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)

1238case SymbolKind.Method: 8132case SymbolKind.Method: 9228if (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)

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

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

587case SymbolKind.Method:

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

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

SymbolDisplay\SymbolDisplayVisitor.cs (1)

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

SymbolDisplay\SymbolDisplayVisitor.Types.cs (1)

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

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

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

267targetSymbolKind = SymbolKind.Method; 274targetSymbolKind = SymbolKind.Method; 278targetSymbolKind = SymbolKind.Method; 309case SymbolKind.Method: 1234if (typeParam.ContainingSymbol.Kind != SymbolKind.Method)

Symbols\ExtendedErrorTypeSymbol.cs (1)

319case SymbolKind.Method:

Symbols\MemberSignatureComparer.cs (2)

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

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

1515int index = GetIndexOfFirstMember(members, SymbolKind.Method); 1521if (members[index].Kind != SymbolKind.Method) 1539if (index >= members.Length || members[index].Kind != SymbolKind.Method) 1567if (index == members.Length || members[index].Kind != SymbolKind.Method) 1729Debug.Assert(SymbolKind.Field.ToSortOrder() < SymbolKind.Method.ToSortOrder()); 1730Debug.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) ? 681bool inherited = (_containingSymbol.Kind == SymbolKind.Method) && ((MethodSymbol)_containingSymbol).IsOverride;

Symbols\MethodSymbol.cs (1)

657return SymbolKind.Method;

Symbols\MethodSymbolExtensions.cs (1)

109case SymbolKind.Method:

Symbols\NamedTypeSymbol.cs (1)

404if (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: 1032if (otherMember.Kind == SymbolKind.Method &&

Symbols\Retargeting\RetargetingSymbolTranslator.cs (1)

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

Symbols\Source\ExplicitInterfaceHelpers.cs (1)

327var errorType = implementingMember.Kind is SymbolKind.Method

Symbols\Source\LocalFunctionSymbol.cs (1)

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

Symbols\Source\ModifierUtils.cs (1)

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

Symbols\Source\ParameterHelpers.cs (1)

1121if (current.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) 550case SymbolKind.Method: 719if (hiddenMember.Kind == SymbolKind.Method && !((MethodSymbol)hiddenMember).CanBeHiddenByMember(symbol)) 767var overridingMemberIsMethod = overridingMember.Kind == SymbolKind.Method; 886var overridingMemberIsMethod = overridingMember.Kind == SymbolKind.Method; 1715case SymbolKind.Method: 1745case SymbolKind.Method: 1878if ((object)implementingMember == null || implementingMember.Kind != SymbolKind.Method)

Symbols\Source\SourceMemberContainerSymbol.cs (10)

1512if (member.Kind != SymbolKind.Method && this.ContainingType is { } containingType) 2272if (symbol.Kind != SymbolKind.Method || lastSym.Kind != SymbolKind.Method) 2283if (lastSym.Kind == SymbolKind.Method) 2870if (member.Kind != SymbolKind.Method || ((MethodSymbol)member).MethodKind != MethodKind.Destructor) 4571if (symbol.Kind != SymbolKind.Method) 4610if (symbol.Kind != SymbolKind.Method) 4771case SymbolKind.Method: 4841case SymbolKind.Method: 5689if (member.Kind == SymbolKind.Method)

Symbols\Source\SourceParameterSymbol.cs (1)

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

Symbols\SubstitutedTypeParameterSymbol.cs (1)

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

Symbols\Symbol_Attributes.cs (3)

54case SymbolKind.Method: 929Debug.Assert(this.Kind == SymbolKind.Method); 950case SymbolKind.Method:

Symbols\Symbol.cs (6)

675case SymbolKind.Method: 735if (this.Kind == SymbolKind.Method) 912Debug.Assert(this.Kind == SymbolKind.NamedType || this.Kind == SymbolKind.Method); 1233case SymbolKind.Method: 1695case SymbolKind.Method: 1764case SymbolKind.Method:

Symbols\SymbolDistinguisher.cs (1)

61case SymbolKind.Method:

Symbols\SymbolExtensions.cs (6)

148while (containingMember is object && containingMember.Kind == SymbolKind.Method) 167case SymbolKind.Method: 208case SymbolKind.Method: 339case SymbolKind.Method: 486case SymbolKind.Method: 535SymbolKind.Method => ((MethodSymbol)symbol).RequiresInstanceReceiver,

Symbols\SymbolKindExtensions.cs (1)

34case SymbolKind.Method:

Symbols\Tuples\TupleTypeSymbol.cs (2)

698case SymbolKind.Method: 1069case SymbolKind.Method:

Symbols\TypeSymbol.cs (11)

742case SymbolKind.Method: 810Debug.Assert(interfaceMember.Kind == SymbolKind.Method || interfaceMember.Kind == SymbolKind.Property || interfaceMember.Kind == SymbolKind.Event); 1012if (!canBeImplementedImplicitlyInCSharp9 && interfaceMember.Kind == SymbolKind.Method && 1514associated = implementation.Kind == SymbolKind.Method 1633if (interfaceMember.Kind == SymbolKind.Method) 1683if (interfaceMember.Kind == SymbolKind.Method) 1967case SymbolKind.Method: 2033case SymbolKind.Method: 2053case SymbolKind.Method: 2318Debug.Assert(interfaceMember.Kind != SymbolKind.Method || (object)interfaceMember == ((MethodSymbol)interfaceMember).ConstructedFrom); 2433case SymbolKind.Method:

Symbols\TypeSymbolExtensions.cs (2)

375return p.ContainingSymbol.Kind == SymbolKind.Method; 1830case SymbolKind.Method:

Symbols\VarianceSafety.cs (1)

49case SymbolKind.Method:

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

442case SymbolKind.Method:

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

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

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

722SymbolKind.Method => Glyph.MethodPublic, 755(symbolKindOrTypeKind.MethodKind.HasValue ? SymbolKind.Method : throw ExceptionUtilities.Unreachable());

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;

LanguageServices\CSharpSymbolDisplayService.SymbolDescriptionBuilder.cs (1)

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

NavigationBar\CSharpNavigationBarItemService.cs (1)

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

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

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

Microsoft.NetCore.Analyzers\InteropServices\CSharpDynamicInterfaceCastableImplementation.Fixer.cs (1)

43SymbolKind.Method => GenerateMethodImplementation((IMethodSymbol)member),

Recommendations\CSharpRecommendationServiceRunner.cs (1)

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

Rename\CSharpRenameRewriterLanguageService.cs (3)

840else if (renamedSymbol.Kind == SymbolKind.Method) 956(renameSymbol.Kind == SymbolKind.Method && 1021if (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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Extensions\ExpressionSyntaxExtensions.cs (1)

442case SymbolKind.Method:

Symbols\ISymbolExtensions_Accessibility.cs (1)

143case SymbolKind.Method:

Symbols\ISymbolExtensions.cs (2)

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

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

CallHierarchy\AbstractCallHierarchyService.cs (2)

78=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event or SymbolKind.Field; 99if (symbol.Kind is SymbolKind.Property or SymbolKind.Event or SymbolKind.Method)

CodeFixes\Suppression\AbstractSuppressionCodeFixProvider.cs (1)

361case SymbolKind.Method:

CodeLens\CodeLensReferencesService.cs (1)

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

Completion\CommonCompletionUtilities.cs (1)

104case SymbolKind.Method:

Completion\Providers\AbstractOverrideCompletionProvider.cs (1)

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

Debugging\AbstractBreakpointResolver.cs (2)

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

DocumentHighlighting\AbstractDocumentHighlightsService.cs (1)

141case SymbolKind.Method:

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (4)

318SymbolKind.Method => GetDisplayName((IMethodSymbol)symbol), 2653case SymbolKind.Method: 3717=> symbol.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Field or SymbolKind.Event; 4896var 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)

489if (declaredSymbol?.Kind is SymbolKind.Property or SymbolKind.Method or SymbolKind.Event)

MetadataAsSource\AbstractMetadataAsSourceService.WrappedNamedTypeSymbol.cs (2)

36SymbolKind.Method or 49SymbolKind.Method => new WrappedMethodSymbol((IMethodSymbol)m, canImplementImplicitly, docCommentFormattingService),

MetadataAsSource\MetadataAsSourceFileService.cs (1)

301case SymbolKind.Method:

Rename\SymbolicRenameInfo.cs (2)

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

Shared\Extensions\ISymbolExtensions_2.cs (1)

96case 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\roslyn\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\roslyn\src\Analyzers\Core\Analyzers\RemoveUnnecessarySuppressions\AbstractRemoveUnnecessaryPragmaSuppressionsDiagnosticAnalyzer.cs (1)

782case SymbolKind.Method:

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

229compilationStartContext.RegisterSymbolAction(AnalyzeSymbolDeclaration, SymbolKind.Method, SymbolKind.Field, SymbolKind.Property, SymbolKind.Event); 947case SymbolKind.Method:

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

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

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

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

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\AvoidOutParameters.cs (1)

47context.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\CancellationTokenParametersMustComeLast.cs (1)

155SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotDeclareProtectedMembersInSealedTypes.cs (1)

65}, SymbolKind.Method, SymbolKind.Property, SymbolKind.Event, SymbolKind.Field);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotDeclareStaticMembersOnGenericTypes.cs (1)

66}, SymbolKind.Method, SymbolKind.Property);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotExposeGenericLists.cs (1)

131}, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotHideBaseClassMethods.cs (1)

41context.RegisterSymbolAction(SymbolAnalyzer, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotOverloadOperatorEqualsOnReferenceTypes.cs (1)

78}, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\DoNotPassTypesByReference.cs (1)

69}, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldHaveCorrectPrefix.cs (2)

83case SymbolKind.Method: 92SymbolKind.Method,

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotContainTypeNames.cs (1)

117SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotContainUnderscores.cs (2)

226SymbolKind.Method, SymbolKind.Property, SymbolKind.Field, SymbolKind.Event // Members 287else if (containingSymbol.Kind == SymbolKind.Method && !IsInvalidSymbol(containingSymbol, symbolAnalysisContext))

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotHaveIncorrectSuffix.cs (1)

286}, SymbolKind.Event, SymbolKind.Field, SymbolKind.Method, SymbolKind.Property);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\IdentifiersShouldNotMatchKeywords.cs (3)

80SymbolKind.Method, 101compilationStartAnalysisContext.RegisterSymbolAction(AnalyzeMemberRule, SymbolKind.Event, SymbolKind.Method, SymbolKind.Property); 102compilationStartAnalysisContext.RegisterSymbolAction(AnalyzeMemberParameterRule, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\InterfaceMethodsShouldBeCallableByChildTypes.cs (1)

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

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\InterfaceMethodsShouldBeCallableByChildTypes.Fixer.cs (1)

199SymbolKind.Method => ((IMethodSymbol)symbol).ExplicitInterfaceImplementations,

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\MovePInvokesToNativeMethodsClass.cs (1)

64return symbol.Kind == SymbolKind.Method && ((IMethodSymbol)symbol).GetDllImportData() != null;

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\ParameterNamesShouldMatchBaseDeclaration.cs (1)

43context.RegisterSymbolAction(AnalyzeMethodSymbol, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\PropertyNamesShouldNotMatchGetMethods.cs (4)

48context.RegisterSymbolAction(ctx => AnalyzeSymbol(ctx, obsoleteAttributeType), SymbolKind.Property, SymbolKind.Method); 86else if (symbol.Kind == SymbolKind.Method && symbol.Name.StartsWith(Get, StringComparison.Ordinal)) 126if (symbol.Kind == SymbolKind.Property && member.Kind == SymbolKind.Method) 133if (symbol.Kind == SymbolKind.Method

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\ProvideObsoleteAttributeMessage.cs (1)

50SymbolKind.Method,

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\UriParametersShouldNotBeStrings.cs (1)

54c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\UriReturnValuesShouldNotBeStrings.cs (1)

52c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\ApiDesignGuidelines\UseEventsWhereAppropriate.cs (1)

74}, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\Maintainability\CodeMetricsAnalyzer.cs (4)

244CA1502RuleId => symbolKind == SymbolKind.Method, 247SymbolKind.NamedType or SymbolKind.Method or SymbolKind.Field or SymbolKind.Property or SymbolKind.Event => true, 252SymbolKind.NamedType or SymbolKind.Method or SymbolKind.Field or SymbolKind.Property or SymbolKind.Event => true, 396symbolKind = SymbolKind.Method;

Microsoft.CodeQuality.Analyzers\Maintainability\DoNotIgnoreMethodResults.cs (1)

265if (operationContext.ContainingSymbol.Kind != SymbolKind.Method)

Microsoft.CodeQuality.Analyzers\QualityGuidelines\PreferJaggedArraysOverMultidimensional.cs (1)

66context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);

Microsoft.CodeQuality.Analyzers\QualityGuidelines\SealMethodsThatSatisfyPrivateInterfaces.Fixer.cs (1)

117if (this.Symbol.IsAbstract && !_newModifiers.IsAbstract && this.Symbol.Kind == SymbolKind.Method)

Microsoft.NetCore.Analyzers\Data\ReviewSqlQueriesForSecurityVulnerabilities.cs (1)

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

Microsoft.NetCore.Analyzers\InteropServices\AvoidStringBuilderPInvokeParameters.cs (1)

43compilationContext.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, stringBuilderType), SymbolKind.Method);

Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshallingAnalyzer.DelegateInteropUsageAnalyzer.cs (1)

48context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);

Microsoft.NetCore.Analyzers\InteropServices\DisableRuntimeMarshallingAnalyzer.DisabledRuntimeMarshallingAssemblyAnalyzer.cs (1)

43context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);

Microsoft.NetCore.Analyzers\InteropServices\DoNotUseOutAttributeStringPInvokeParameters.cs (1)

43compilationContext.RegisterSymbolAction(symbolContext => AnalyzeSymbol(symbolContext, outAttributeType), SymbolKind.Method);

Microsoft.NetCore.Analyzers\InteropServices\PInvokeDiagnosticAnalyzer.cs (1)

82context.RegisterSymbolAction(new SymbolAnalyzer(dllImportType, marshalAsType, stringBuilderType, unmanagedType).AnalyzeSymbol, SymbolKind.Method);

Microsoft.NetCore.Analyzers\InteropServices\UseValidPlatformString.cs (1)

26private static readonly ImmutableArray<SymbolKind> s_symbols = ImmutableArray.Create(SymbolKind.NamedType, SymbolKind.Method, SymbolKind.Property, SymbolKind.Field, SymbolKind.Event);

Microsoft.NetCore.Analyzers\Performance\ConstantExpectedAnalyzer.cs (1)

141context.RegisterSymbolAction(context => OnMethodSymbol(context, constantExpectedContext), SymbolKind.Method);

Microsoft.NetCore.Analyzers\Runtime\AttributeStringLiteralsShouldParseCorrectly.cs (2)

105case SymbolKind.Method: 126SymbolKind.Method, SymbolKind.Property, SymbolKind.Field, SymbolKind.Event);

Microsoft.NetCore.Analyzers\Runtime\CallGCSuppressFinalizeCorrectly.cs (1)

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

Microsoft.NetCore.Analyzers\Runtime\DetectPreviewFeatureAnalyzer.cs (1)

31private static readonly ImmutableArray<SymbolKind> s_symbols = ImmutableArray.Create(SymbolKind.NamedType, SymbolKind.Method, SymbolKind.Property, SymbolKind.Field, SymbolKind.Event);

Microsoft.NetCore.Analyzers\Runtime\DisposableFieldsShouldBeDisposed.cs (1)

110foreach (var method in type.GetMembers().WhereAsArray(x => x.IsVirtual && x.Kind == SymbolKind.Method))

Microsoft.NetCore.Analyzers\Runtime\DoNotPassLiteralsAsLocalizedParameters.cs (1)

225Debug.Assert(parameterSymbol.ContainingSymbol.Kind == SymbolKind.Method);

Microsoft.NetCore.Analyzers\Runtime\ModuleInitializerAttributeShouldNotBeUsedInLibraries.cs (1)

81SymbolKind.Method);

Microsoft.NetCore.Analyzers\Runtime\UseAsyncMethodInAsyncContext.cs (7)

70GetSymbolAndAddToList("Wait", WellKnownTypeNames.SystemThreadingTasksTask, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 71GetSymbolAndAddToList("WaitAll", WellKnownTypeNames.SystemThreadingTasksTask, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 72GetSymbolAndAddToList("WaitAny", WellKnownTypeNames.SystemThreadingTasksTask, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 75GetSymbolAndAddToList("GetResult", WellKnownTypeNames.SystemRuntimeCompilerServicesTaskAwaiter, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 76GetSymbolAndAddToList("GetResult", WellKnownTypeNames.SystemRuntimeCompilerServicesValueTaskAwaiter, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 77GetSymbolAndAddToList("Sleep", WellKnownTypeNames.SystemThreadingThread, SymbolKind.Method, syncBlockingSymbols, wellKnownTypeProvider); 112|| InspectAndReportBlockingMemberAccess(context, methodSymbol, syncBlockingSymbols, SymbolKind.Method)

Microsoft.NetCore.Analyzers\Security\DoNotCallDangerousMethodsInDeserialization.cs (1)

183calledSymbol.ContainingSymbol.Kind == SymbolKind.Method ||

Microsoft.NetCore.Analyzers\Security\DoNotDisableRequestValidation.cs (1)

88}, SymbolKind.Method);

Microsoft.NetCore.Analyzers\Security\UseDefaultDllImportSearchPathsAttribute.cs (1)

148}, SymbolKind.Method);

Microsoft.NetFramework.Analyzers\MarkVerbHandlersWithValidateAntiforgeryTokenAnalyzer.cs (1)

164SymbolKind.Method);

src\47c588c5b8785708\ParameterValidationAnalysis.ParameterValidationDataFlowOperationVisitor.cs (1)

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

src\9382845807600969\AbstractDataFlowAnalysisContext.cs (1)

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

src\ffd9070534249528\PointsToAnalysis.PointsToDataFlowOperationVisitor.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.cs (3)

38SymbolKind.Method or 272SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context), 310SymbolKind.Method => MethodMetricData.Compute((IMethodSymbol)symbol, context),

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\CodeMetrics\MetricsHelper.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\DoNotCatchGeneralUnlessRethrown.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\IOperationExtensions.cs (1)

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

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Extensions\ISymbolExtensions.cs (1)

245return member != null && member.Kind == SymbolKind.Method && member.MatchMemberByName(type, name);

src\sdk\src\Microsoft.CodeAnalysis.NetAnalyzers\src\Utilities\Compiler\Options\SymbolNamesWithValueOption.cs (2)

161'M' => SymbolKind.Method, 271case SymbolKind.Method:

src\roslyn\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\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

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

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

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

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

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

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

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

Editing\SyntaxGenerator.cs (3)

528var invoke = symbol.Type.GetMembers("Invoke").FirstOrDefault(m => m.Kind == SymbolKind.Method) as IMethodSymbol; 741case SymbolKind.Method: 879case 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)

83case SymbolKind.Method:

Rename\ConflictEngine\ConflictResolver.cs (2)

253.Where(s => s.Kind != SymbolKind.Method || renamedSymbol.Kind != SymbolKind.Method);

Rename\RenameUtilities.cs (1)

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

Shared\Extensions\ISymbolExtensions.cs (1)

279case SymbolKind.Method:

Shared\Extensions\ITypeSymbolExtensions.cs (1)

50not SymbolKind.Method and

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

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

74public override SymbolKind Kind => SymbolKind.Method;

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

28case SymbolKind.Method:

Analyzers\MembersMustExistAnalyzer.cs (1)

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

Analyzers\PinvokeAnalyzer.cs (1)

32obj.RegisterSymbolAction(AnalyzeMethod, 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\VtableIndexStubDiagnosticsAnalyzer.cs (1)

77}, SymbolKind.Method);

Analyzers\JSImportExportDiagnosticsAnalyzer.cs (1)

97}, SymbolKind.Method);

Analyzers\ConvertToLibraryImportAnalyzer.cs (1)

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

Analyzers\LibraryImportDiagnosticsAnalyzer.cs (1)

77}, SymbolKind.Method);

Analyzers\ShapeBreakingDiagnosticSuppressor.cs (1)

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

DownlevelLibraryImportDiagnosticsAnalyzer.cs (2)

71}, SymbolKind.Method); 87}, 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);

AbstractDoNotCopyValue.cs (2)

158SymbolKind.Method, 1528case SymbolKind.Method:

src\a16f30e1d256badc\AbstractTypeInferenceService.AbstractTypeInferrer.cs (1)

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

src\roslyn\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\roslyn\src\RoslynAnalyzers\Utilities\Compiler\CodeMetrics\CodeAnalysisMetricData.NamedTypeMetricData.cs (1)

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

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

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

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

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

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

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

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

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

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

171case SymbolKind.Method:

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

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

src\roslyn\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\roslyn\src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Simplification\SimplifierOptions.cs (1)

48SymbolKind.Method => QualifyMethodAccess,

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

1053if (originalSymbol.IsKind(SymbolKind.Method) || originalSymbol.IsIndexer())

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

143case SymbolKind.Method:

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

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

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

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

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

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

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

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

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

74public override SymbolKind Kind => SymbolKind.Method;

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

28case SymbolKind.Method:

SymbolDeclaredEventMustBeGeneratedForSourceSymbols.cs (1)

108invocationSymbol.Kind == SymbolKind.Method)

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

442case SymbolKind.Method:

IntrinsicsInSystemPrivateCoreLibAnalyzer.cs (1)

186}, SymbolKind.Method);