MethodKind

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

357Debug.Assert(targetMethod.MethodKind is MethodKind.LambdaMethod or MethodKind.LocalFunction);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\TaintedDataAnalysis.TaintedDataOperationVisitor.cs (2)

637if (method.MethodKind == MethodKind.Constructor 694if (method.MethodKind == MethodKind.Constructor

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Analysis\TaintedDataAnalysis\WebInputSources.cs (1)

116|| methodSymbol.MethodKind != MethodKind.Ordinary

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

159Debug.Assert(localFunction.MethodKind == MethodKind.LocalFunction);

src\RoslynAnalyzers\Utilities\FlowAnalysis\FlowAnalysis\Framework\DataFlow\DataFlowOperationVisitor.cs (9)

632Debug.Assert(localFunction.MethodKind == MethodKind.LocalFunction); 2480else if (invokedMethod.MethodKind == MethodKind.Constructor) 2551method.MethodKind == MethodKind.DelegateInvoke) 3291if (targetMethod.MethodKind == MethodKind.LocalFunction) 3335if (targetMethod.MethodKind == MethodKind.LocalFunction) 3345Debug.Assert(targetMethod.MethodKind is MethodKind.LambdaMethod or 3346MethodKind.DelegateInvoke); 3471computeValueForInvocation: () => method.MethodKind == MethodKind.LocalFunction ? 3622if (methodReference.Method.MethodKind == MethodKind.LocalFunction)

Microsoft.CodeAnalysis.BannedApiAnalyzers (29)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (6)

Microsoft.CodeAnalysis.CodeStyle (97)

src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (1)

19methodSymbol.MethodKind == MethodKind.Constructor &&

src\Analyzers\Core\Analyzers\QualifyMemberAccess\AbstractQualifyMemberAccessDiagnosticAnalyzer.cs (1)

146return symbol == null || symbol.IsStatic || symbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction };

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

790/// 4. If method, then it is a constructor OR a method with <see cref="MethodKind.Ordinary"/>, 812case MethodKind.Constructor: 842case MethodKind.Ordinary:

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (1)

298if (method.MethodKind != MethodKind.Constructor)

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

292if (((IMethodSymbol)symbolInfo.Symbol).MethodKind == MethodKind.LocalFunction)

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

48if (symbol.MethodKind == MethodKind.BuiltinOperator)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (6)

228if (member is IMethodSymbol { IsStatic: true, IsAbstract: true, MethodKind: MethodKind.UserDefinedOperator } method) 426if (method is { MethodKind: MethodKind.UserDefinedOperator or MethodKind.Conversion } || 427method is { MethodKind: MethodKind.Ordinary, CanBeReferencedByName: true }) 637IMethodSymbol { MethodKind: MethodKind.Ordinary, CanBeReferencedByName: true } => true, 638IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator } => true,

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

30MethodKind: MethodKind.Constructor, 62MethodKind: MethodKind.Constructor,

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

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

153if (symbol is IMethodSymbol { MethodKind: MethodKind.BuiltinOperator })

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\MethodKindExtensions.cs (3)

9public static bool IsPropertyAccessor(this MethodKind kind) 10=> kind is MethodKind.PropertyGet or MethodKind.PropertySet;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.Walker.cs (3)

325case MethodKind.AnonymousFunction: 326case MethodKind.DelegateInvoke: 338case MethodKind.LocalFunction:

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

109private static readonly SymbolKindOrTypeKind s_method = new(MethodKind.Ordinary); 110private static readonly SymbolKindOrTypeKind s_localFunction = new(MethodKind.LocalFunction); 314case MethodKind.Ordinary: 317case MethodKind.LocalFunction:

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

46return method.MethodKind is MethodKind.Ordinary or 47MethodKind.LocalFunction;

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

75new SymbolKindOrTypeKind(MethodKind.Ordinary), 76new SymbolKindOrTypeKind(MethodKind.LocalFunction), 174case MethodKind.AnonymousFunction: 175case MethodKind.LocalFunction: 303foreach (var methodKindElement in symbolKindListElement.Elements(nameof(MethodKind))) 354public SymbolKindOrTypeKind(MethodKind methodKind) 361public MethodKind? MethodKind => (_category == SymbolCategory.Method) ? (MethodKind)_kind : null; 368SymbolCategory.Method => symbol is IMethodSymbol method && method.MethodKind == (MethodKind)_kind, 377SymbolCategory.Method => new XElement(nameof(MethodKind), GetMethodKindString((MethodKind)_kind)), 393private static string GetMethodKindString(MethodKind methodKind) 400CodeAnalysis.MethodKind.SharedConstructor => nameof(CodeAnalysis.MethodKind.StaticConstructor), 401CodeAnalysis.MethodKind.AnonymousFunction => nameof(CodeAnalysis.MethodKind.LambdaMethod), 432CodeAnalysis.SymbolKind.Method => new(CodeAnalysis.MethodKind.Ordinary), 441=> new((MethodKind)Enum.Parse(typeof(MethodKind), methodKindElement.Value)); 449public static implicit operator SymbolKindOrTypeKind(MethodKind symbolKind)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SemanticFacts\ISemanticFactsExtensions.cs (1)

113methodSymbol.MethodKind == MethodKind.UserDefinedOperator;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

74/// cref="IRangeVariableSymbol"/> and <see cref="MethodKind.LocalFunction"/> <see cref="IMethodSymbol"/>s can also 321IMethodSymbol { MethodKind: MethodKind.LocalFunction } => true,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

143if (symbol.MethodKind == MethodKind.Conversion)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (4)

373case MethodKind.AnonymousFunction: 378case MethodKind.BuiltinOperator: 383case MethodKind.ReducedExtension: 388case MethodKind.LocalFunction:

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

407if (methodSymbol.MethodKind == MethodKind.LocalFunction && newMethodSymbol.MethodKind == MethodKind.LocalFunction) 477if (symbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction } methodSymbol && 478newSymbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction } newMethodSymbol) 876=> symbol is IMethodSymbol { MethodKind: MethodKind.DelegateInvoke };

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

78if ((method1.MethodKind == MethodKind.AnonymousFunction) != 79(method2.MethodKind == MethodKind.AnonymousFunction)) 84if (method1.MethodKind != MethodKind.AnonymousFunction)

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

199if (x is { MethodKind: MethodKind.DelegateInvoke, ContainingType.IsAnonymousType: true }) 204if (x.MethodKind == MethodKind.FunctionPointerSignature)

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

175if (x.MethodKind == MethodKind.ReducedExtension) 194if (x.MethodKind is MethodKind.AnonymousFunction or 195MethodKind.LocalFunction) 247private static bool AreCompatibleMethodKinds(MethodKind kind1, MethodKind kind2) 254if ((kind1 == MethodKind.Ordinary && kind2.IsPropertyAccessor()) || 255(kind1.IsPropertyAccessor() && kind2 == MethodKind.Ordinary)) 261if ((kind1 == MethodKind.BuiltinOperator && kind2 == MethodKind.UserDefinedOperator) || 262(kind1 == MethodKind.UserDefinedOperator && kind2 == MethodKind.BuiltinOperator))

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

112if (x.MethodKind == MethodKind.AnonymousFunction)

Microsoft.CodeAnalysis.CodeStyle.Fixes (36)

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

138var isConstructorInitializer = candidates.All(m => m.MethodKind == MethodKind.Constructor);

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (3)

141if (method.MethodKind == MethodKind.ReducedExtension && insertionIndex < existingParameters.Count) 167if (method.MethodKind != MethodKind.Constructor) 193if (parameter.ContainingSymbol is not IMethodSymbol { MethodKind: MethodKind.Constructor, DeclaringSyntaxReferences: [var reference] } constructor)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateConversionService.State.cs (2)

59MethodKind = MethodKind.Conversion; 83MethodKind = MethodKind.Conversion;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)

54MethodKind = MethodKind.Ordinary;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (2)

85MethodKind = MethodKind.Ordinary; 124MethodKind = MethodKind.Ordinary;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.State.cs (1)

42public MethodKind MethodKind { get; internal set; }

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (2)

370return method1.MethodKind == MethodKind.Ordinary && 371method2.MethodKind == MethodKind.Ordinary &&

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

59var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 78var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary)); 88var kinds = ImmutableArray.Create(new SymbolKindOrTypeKind(MethodKind.Ordinary));

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (4)

166MethodKind methodKind = MethodKind.Ordinary, 187MethodKind methodKind = MethodKind.Ordinary,

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

77public virtual MethodKind MethodKind => MethodKind.Ordinary;

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

32public override MethodKind MethodKind => MethodKind.Constructor;

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

39public override MethodKind MethodKind => MethodKind.Conversion;

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

23public override MethodKind MethodKind => MethodKind.Destructor;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationMethodSymbol.cs (5)

25public override MethodKind MethodKind { get; } 40MethodKind methodKind = MethodKind.Ordinary, 47Debug.Assert(!isInitOnly || methodKind == MethodKind.PropertySet); 48this.IsInitOnly = methodKind == MethodKind.PropertySet && isInitOnly;

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

173return [.. this.GetMembers().OfType<IMethodSymbol>().Where(m => m.MethodKind == MethodKind.Constructor && !m.IsStatic)]; 182return [.. this.GetMembers().OfType<IMethodSymbol>().Where(m => m.MethodKind == MethodKind.StaticConstructor && m.IsStatic)];

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

37public override MethodKind MethodKind => MethodKind.UserDefinedOperator;

Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (6)

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

120case MethodKind methodKind: 300[new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)], 331[new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary)], 552[new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction)], 770new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.Ordinary), 771new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction),

Microsoft.CodeAnalysis.CSharp (611)

Binder\Binder.ValueChecks.cs (7)

1457MethodKind desiredMethodKind = fieldIsStatic ? MethodKind.StaticConstructor : MethodKind.Constructor; 1919if (method.MethodKind == MethodKind.Constructor || method.IsInitOnly) 2598if (method.MethodKind == MethodKind.Constructor) 5597MethodKind.Ordinary, 5637MethodKind.Ordinary,

Binder\Binder_Await.cs (1)

175if (method.MethodKind == MethodKind.AnonymousFunction)

Binder\Binder_Crefs.cs (2)

795MethodKind candidateMethodKind = candidateMethod.MethodKind; 799int signatureMemberArity = candidateMethodKind == MethodKind.Constructor

Binder\Binder_Expressions.cs (11)

1513ContainingMember() is MethodSymbol { MethodKind: MethodKind.PropertyGet or MethodKind.PropertySet, AssociatedSymbol: PropertySymbol { IsIndexer: false } }) 1981return (containingMethod.MethodKind == MethodKind.AnonymousFunction || containingMethod.MethodKind == MethodKind.LocalFunction) && !IsInsideNameof; // false in EE evaluation method 2119(this.ContainingMember() is MethodSymbol { MethodKind: MethodKind.Constructor } containingMember && (object)containingMember != primaryCtor)) && // We are in a non-primary instance constructor 2182this.ContainingMemberOrLambda is MethodSymbol { MethodKind: MethodKind.AnonymousFunction or MethodKind.LocalFunction } && 4823Debug.Assert(constructor.MethodKind == MethodKind.Constructor || 4824constructor.MethodKind == MethodKind.StaticConstructor); // error scenario: constructor initializer on static constructor 6632Debug.Assert(constructor.MethodKind == MethodKind.Constructor || constructor.MethodKind == MethodKind.StaticConstructor);

Binder\Binder_Invocation.cs (2)

815if (result is null && finalApplicableCandidates[0].LeastOverriddenMember.MethodKind != MethodKind.LocalFunction) 904if (singleCandidate.MethodKind != MethodKind.LocalFunction)

Binder\Binder_Lookup.cs (1)

1488else if ((options & LookupOptions.MustBeOperator) != 0 && unwrappedSymbol is not MethodSymbol { MethodKind: MethodKind.UserDefinedOperator })

Binder\Binder_Statements.cs (3)

1810MethodKind.StaticConstructor : 1811MethodKind.Constructor) || 3825if (constructor.MethodKind != MethodKind.Constructor || constructor.IsExtern)

Binder\InMethodBinder.cs (3)

87internal override bool IsNestedFunctionBinder => _methodSymbol.MethodKind == MethodKind.LocalFunction; 272if (((MethodSymbol)newSymbol).MethodKind == MethodKind.LocalFunction) 308if (((MethodSymbol)newSymbol).MethodKind == MethodKind.LocalFunction)

Binder\LocalBinderFactory.cs (1)

310SourcePropertyAccessorSymbol { MethodKind: MethodKind.PropertySet } setter => getSetterParameters(setter),

Binder\LockBinder.cs (1)

122MethodKind: MethodKind.Ordinary,

Binder\MethodGroupResolution.cs (1)

104MethodGroup.Methods[0].MethodKind == MethodKind.LocalFunction;

Binder\Semantics\AccessCheck.cs (1)

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

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

512Debug.Assert(firstSupported.Member is MethodSymbol { MethodKind: MethodKind.Constructor });

BoundTree\BoundNodeExtensions.cs (1)

62return method.MethodKind == MethodKind.Constructor &&

CodeGen\CodeGenerator_HasHome.cs (2)

252return containingSymbol is MethodSymbol { MethodKind: MethodKind.StaticConstructor } or FieldSymbol { IsStatic: true }; 256return (containingSymbol is MethodSymbol { MethodKind: MethodKind.Constructor } or FieldSymbol { IsStatic: false } or MethodSymbol { IsInitOnly: true }) &&

CodeGen\EmitExpression.cs (1)

2186if (method.IsEffectivelyReadOnly && method.MethodKind != MethodKind.Constructor)

Compilation\CSharpCompilation.cs (1)

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

Compilation\CSharpSemanticModel.cs (2)

1792case MethodSymbol { MethodKind: MethodKind.LambdaMethod }: 4790if (call.InvokedAsExtensionMethod && method.IsExtensionMethod && method.MethodKind != MethodKind.ReducedExtension)

Compilation\MemberSemanticModel.cs (1)

2342Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compilation\MethodBodySemanticModel.cs (1)

241if (MemberSymbol is MethodSymbol methodSymbol && methodSymbol.MethodKind == MethodKind.Constructor &&

Compilation\SyntaxTreeSemanticModel.cs (1)

2442Debug.Assert(symbol is LocalSymbol or ParameterSymbol or MethodSymbol { MethodKind: MethodKind.LambdaMethod });

Compiler\ClsComplianceChecker.cs (1)

736if (method.MethodKind == MethodKind.DelegateInvoke)

Compiler\MethodBodySynthesizer.cs (5)

176Debug.Assert(accessor.MethodKind == MethodKind.PropertyGet || accessor.MethodKind == MethodKind.PropertySet); 191if (accessor.MethodKind == MethodKind.PropertyGet) 197Debug.Assert(accessor.MethodKind == MethodKind.PropertySet); 532Debug.Assert(method.MethodKind == MethodKind.Destructor);

Compiler\MethodCompiler.cs (7)

534(method.MethodKind == MethodKind.Constructor || method.IsScriptInitializer) ? processedInstanceInitializers : 535method.MethodKind == MethodKind.StaticConstructor ? processedStaticInitializers : 1099if ((methodSymbol.MethodKind == MethodKind.Constructor || methodSymbol.MethodKind == MethodKind.StaticConstructor) && 1859if (method.MethodKind == MethodKind.StaticConstructor && 2035if (method.MethodKind == MethodKind.Destructor && body != null) 2437if (method.MethodKind == MethodKind.Constructor && !method.IsExtern)

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.cs (1)

116if (symbol.MethodKind == MethodKind.Conversion)

Emitter\Model\MethodSymbolAdapter.cs (5)

388return AdaptedMethodSymbol.MethodKind == MethodKind.Constructor; 637return this.MethodKind == MethodKind.Constructor 638|| this.MethodKind == MethodKind.StaticConstructor; 647Debug.Assert(this.MethodKind != MethodKind.Destructor); 651!(this.IsVirtual || this.IsOverride || this.IsAbstract || this.MethodKind == MethodKind.Destructor));

Emitter\Model\NamedTypeSymbolAdapter.cs (3)

358else if (method.MethodKind == MethodKind.Destructor && AdaptedNamedTypeSymbol.SpecialType != SpecialType.System_Object) 369if ((object)objectMethod != null && objectMethod.MethodKind == MethodKind.Destructor) 631if ((alwaysIncludeConstructors && method.MethodKind == MethodKind.Constructor) || method is SynthesizedExtensionMarker || method.GetCciAdapter().ShouldInclude(context))

Emitter\Model\PropertySymbolAdapter.cs (3)

78return GetSynthesizedSealedAccessor(MethodKind.PropertyGet); 133return GetSynthesizedSealedAccessor(MethodKind.PropertySet); 277private IMethodReference GetSynthesizedSealedAccessor(MethodKind targetMethodKind)

Emitter\Model\SynthesizedPrivateImplementationDetailsStaticConstructor.cs (2)

24public override MethodKind MethodKind => MethodKind.StaticConstructor;

Emitter\NoPia\EmbeddedMethod.cs (1)

70return UnderlyingMethod.AdaptedMethodSymbol.MethodKind == MethodKind.Constructor;

FlowAnalysis\AbstractFlowPass.cs (2)

1420if (method is null || method.MethodKind != MethodKind.Constructor) 1517Debug.Assert(method?.OriginalDefinition.MethodKind != MethodKind.LocalFunction);

FlowAnalysis\DefiniteAssignment.cs (6)

102&& CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }; 1258Debug.Assert(CurrentSymbol is MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }); 1311if (CurrentSymbol is not MethodSymbol { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Struct }) 2383(currentMethod.MethodKind == MethodKind.AnonymousFunction || 2384currentMethod.MethodKind == MethodKind.LocalFunction) && 2426if (method.MethodKind == MethodKind.LocalFunction)

FlowAnalysis\DefiniteAssignment.LocalFunctions.cs (1)

163((MethodSymbol)symbol).MethodKind == MethodKind.LocalFunction)

FlowAnalysis\DefiniteAssignment.VariableIdentifier.cs (1)

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

FlowAnalysis\FlowAnalysisPass.cs (2)

76Debug.Assert(method.MethodKind != MethodKind.AnonymousFunction); 113Debug.Assert(method.MethodKind == MethodKind.Constructor);

FlowAnalysis\NullableWalker.cs (7)

474Debug.Assert(baseOrThisInitializer is null or { MethodKind: MethodKind.Constructor }); 1549return constructorBody is BoundConstructorMethodBody { Initializer: BoundExpressionStatement { Expression: BoundCall { Method: { MethodKind: MethodKind.Constructor } initializerMethod } } } 1832Debug.Assert(getterNullResilienceData is null || symbol is SourcePropertyAccessorSymbol { MethodKind: MethodKind.PropertyGet }); 2230while (enclosingMemberMethod?.MethodKind is MethodKind.AnonymousFunction or MethodKind.LocalFunction) 6579|| method.MethodKind != MethodKind.Ordinary 8475if (((MethodSymbol)symbol).MethodKind == MethodKind.LocalFunction)

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

460if (node.Method.MethodKind == MethodKind.LocalFunction) 471if (node.MethodOpt?.MethodKind == MethodKind.LocalFunction)

Lowering\ClosureConversion\ClosureConversion.cs (11)

194_seenBaseCall = method.MethodKind != MethodKind.Constructor; // only used for ctors 208(localOrParameter as MethodSymbol)?.MethodKind == MethodKind.LocalFunction); 440originalMethod.MethodKind == MethodKind.LambdaMethod && 794if (_currentMethod.MethodKind == MethodKind.Constructor && 863var loweredSymbol = (node.Method.MethodKind is MethodKind.LambdaMethod or MethodKind.LocalFunction) ? 881Debug.Assert(localFunc.MethodKind == MethodKind.LocalFunction); 1076if (node.Method.MethodKind == MethodKind.LocalFunction) 1341if (node.MethodOpt?.MethodKind == MethodKind.LocalFunction) 1367if (node.TargetMethod.MethodKind == MethodKind.LocalFunction) 1676_currentMethod.MethodKind != MethodKind.StaticConstructor &&

Lowering\DiagnosticsPass_ExpressionTrees.cs (4)

197var diagnostic = _staticLocalOrAnonymousFunction.MethodKind == MethodKind.LocalFunction 212var diagnostic = _staticLocalOrAnonymousFunction.MethodKind == MethodKind.LocalFunction 352else if (method.MethodKind == MethodKind.LocalFunction) 924if ((node.LookupSymbolOpt as MethodSymbol)?.MethodKind == MethodKind.LocalFunction)

Lowering\DiagnosticsPass_Warnings.cs (1)

368if ((object)op == null || op.MethodKind != MethodKind.UserDefinedOperator) continue;

Lowering\ExtensionMethodBodyRewriter.cs (2)

152case MethodKind.LambdaMethod: 155case MethodKind.LocalFunction:

Lowering\ExtensionMethodReferenceRewriter.cs (2)

170method.MethodKind is (MethodKind.Constructor or MethodKind.StaticConstructor) ||

Lowering\InitializerRewriter.cs (2)

22Debug.Assert((method.MethodKind == MethodKind.Constructor) || (method.MethodKind == MethodKind.StaticConstructor));

Lowering\Instrumentation\CodeCoverageInstrumenter.cs (2)

143Debug.Assert(method.MethodKind != MethodKind.LocalFunction && method.MethodKind != MethodKind.AnonymousFunction);

Lowering\Instrumentation\ModuleCancellationInstrumenter.cs (5)

50if (method.MethodKind is not (MethodKind.Constructor or MethodKind.StaticConstructor) && 84if (isMethodBody && _factory.TopLevelMethod.MethodKind == MethodKind.StaticConstructor) 156if (method.MethodKind is not (MethodKind.Ordinary or MethodKind.Constructor))

Lowering\Instrumentation\StackOverflowProbingInstrumenter.cs (3)

40if (method.MethodKind is not (MethodKind.Constructor or MethodKind.StaticConstructor) && 74if (isMethodBody && _factory.TopLevelMethod.MethodKind == MethodKind.StaticConstructor)

Lowering\IteratorRewriter\IteratorFinallyMethodSymbol.cs (2)

70public override MethodKind MethodKind 72get { return MethodKind.Ordinary; }

Lowering\LocalRewriter\DelegateCacheRewriter.cs (2)

128if (targetMethod.MethodKind == MethodKind.LocalFunction) 167Debug.Assert(targetMethod.MethodKind == MethodKind.Ordinary);

Lowering\LocalRewriter\LocalRewriter.DecisionDagRewriter.cs (3)

155node.Method.MethodKind == MethodKind.LocalFunction || 216if (conversion.Method.MethodKind == MethodKind.LocalFunction) 240node.MethodOpt?.MethodKind == MethodKind.LocalFunction;

Lowering\LocalRewriter\LocalRewriter_Call.cs (2)

181if (method.MethodKind is not MethodKind.Ordinary) 667var requiresInstanceReceiver = methodOrIndexer.RequiresInstanceReceiver() && methodOrIndexer is not MethodSymbol { MethodKind: MethodKind.Constructor } and not FunctionPointerMethodSymbol;

Lowering\LocalRewriter\LocalRewriter_CollectionExpression.cs (1)

922if (asSpanMethod is MethodSymbol { MethodKind: MethodKind.Constructor } constructor)

Lowering\LocalRewriter\LocalRewriter_Conversion.cs (1)

580&& _factory.TopLevelMethod.MethodKind != MethodKind.StaticConstructor // Avoid caching twice if people do it manually.

Lowering\LocalRewriter\LocalRewriter_Literal.cs (1)

72if ((curMethod.MethodKind != MethodKind.SharedConstructor ||

Lowering\LocalRewriter\LocalRewriter_Range.cs (3)

167case MethodKind.Constructor: 177case MethodKind.Ordinary: 189case MethodKind.PropertyGet:

Lowering\SynthesizedMethodBaseSymbol.cs (1)

41methodKind: MethodKind.Ordinary,

Lowering\SyntheticBoundNodeFactory.cs (4)

72value.MethodKind != MethodKind.AnonymousFunction && 73value.MethodKind != MethodKind.LocalFunction) 141CurrentFunction.MethodKind == MethodKind.AnonymousFunction || 142CurrentFunction.MethodKind == MethodKind.LocalFunction ||

src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

110Debug.Assert(ctor.MethodKind == MethodKind.Constructor && typeDeclaration.ParameterList is object);

SymbolDisplay\SymbolDisplayVisitor.cs (1)

388return ((IMethodSymbol)symbol).MethodKind == MethodKind.LocalFunction;

SymbolDisplay\SymbolDisplayVisitor.Members.cs (30)

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ConstructorSymbol.cs (2)

43public override MethodKind MethodKind 45get { return MethodKind.Constructor; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.EqualsMethodSymbol.cs (2)

28public override MethodKind MethodKind 30get { return MethodKind.Ordinary; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.GetHashCodeMethodSymbol.cs (2)

32public override MethodKind MethodKind 34get { return MethodKind.Ordinary; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.PropertyAccessorSymbol.cs (2)

29public override MethodKind MethodKind 31get { return MethodKind.PropertyGet; }

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType.ToStringMethodSymbol.cs (2)

32public override MethodKind MethodKind 34get { return MethodKind.Ordinary; }

Symbols\Compilation_WellKnownMembers.cs (8)

254MethodKind targetMethodKind = MethodKind.Ordinary; 262targetMethodKind = MethodKind.Constructor; 273targetMethodKind = MethodKind.PropertyGet; 306MethodKind methodKind = method.MethodKind; 309if (methodKind == MethodKind.Conversion || methodKind == MethodKind.UserDefinedOperator) 311methodKind = MethodKind.Ordinary;

Symbols\ErrorMethodSymbol.cs (4)

199public override MethodKind MethodKind 206return MethodKind.Constructor; 209return MethodKind.Ordinary; 283Debug.Assert(MethodKind == MethodKind.Constructor);

Symbols\Extensions\SourceExtensionImplementationMethodSymbol.cs (3)

34public override MethodKind MethodKind => MethodKind.Ordinary; 47public sealed override bool IsExtensionMethod => !_originalMethod.IsStatic && _originalMethod.MethodKind is MethodKind.Ordinary;

Symbols\Extensions\SynthesizedExtensionMarker.cs (1)

23MethodKind.Ordinary, RefKind.None, GetDeclarationModifiers(), returnsVoid: false, returnsVoidIsSet: false,

Symbols\FunctionPointers\FunctionPointerMethodSymbol.cs (2)

772public override MethodKind MethodKind => MethodKind.FunctionPointerSignature;

Symbols\MemberSymbolExtensions.cs (7)

407return methodSymbol.MethodKind == MethodKind.UserDefinedOperator || methodSymbol.MethodKind == MethodKind.Conversion; 427return symbol.Kind == SymbolKind.Method && ((MethodSymbol)symbol).MethodKind == MethodKind.Conversion; 596case MethodKind.Constructor: 597case MethodKind.StaticConstructor: 609if ((object)method != null && method.MethodKind == MethodKind.Constructor) 674return method.MethodKind == MethodKind.Constructor && method.ParameterCount == 0;

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

125_addMethod.SetAssociatedEvent(this, MethodKind.EventAdd); 126_removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);

Symbols\Metadata\PE\PEMethodSymbol.cs (42)

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

885case "" when !ContainingSymbol.RequiresInstanceReceiver() || ContainingSymbol is MethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.DelegateInvoke }:

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

326_getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet); 331_setMethod.SetAssociatedProperty(this, MethodKind.PropertySet);

Symbols\MethodSymbol.cs (31)

66public abstract MethodKind MethodKind 369protected bool IsValidReadOnlyTarget => !IsStatic && ContainingType.IsStructType() && MethodKind != MethodKind.Constructor && !IsInitOnly; 589internal bool HasSetsRequiredMembers => MethodKind == MethodKind.Constructor && HasSetsRequiredMembersImpl; 600internal static bool CanOverrideOrHide(MethodKind kind) 604case MethodKind.AnonymousFunction: 605case MethodKind.Constructor: 606case MethodKind.Destructor: 607case MethodKind.ExplicitInterfaceImplementation: 608case MethodKind.StaticConstructor: 609case MethodKind.ReducedExtension: 611case MethodKind.Conversion: 612case MethodKind.DelegateInvoke: 613case MethodKind.EventAdd: 614case MethodKind.EventRemove: 615case MethodKind.LocalFunction: 616case MethodKind.UserDefinedOperator: 617case MethodKind.Ordinary: 618case MethodKind.PropertyGet: 619case MethodKind.PropertySet: 655return MethodKind == MethodKind.Constructor && ContainingType.IsScriptClass; 671return ((MethodKind == MethodKind.Constructor || MethodKind == MethodKind.StaticConstructor) && IsImplicitlyDeclared); 682return MethodKind == MethodKind.Constructor && IsImplicitlyDeclared; 757if (!this.IsExtensionMethod || this.MethodKind == MethodKind.ReducedExtension || receiverType.IsVoidType()) 772return (this.IsExtensionMethod && this.MethodKind != MethodKind.ReducedExtension) ? ReducedExtensionMethodSymbol.Create(this) : null; 1040if (!IsStatic || IsAbstract || IsVirtual || MethodKind is not (MethodKind.Ordinary or MethodKind.LocalFunction)) 1200MethodKind is MethodKind.Ordinary 1201or MethodKind.Constructor 1202or MethodKind.UserDefinedOperator 1203or MethodKind.ReducedExtension

Symbols\MethodSymbolExtensions.cs (18)

24return method.IsImplicitlyDeclared && method.MethodKind == MethodKind.AnonymousFunction; 53if (!skipFirstMethodKindCheck && method.MethodKind == MethodKind.Destructor) 100if (hiddenMethod.MethodKind == MethodKind.Destructor) 129case MethodKind.Destructor: 130case MethodKind.Constructor: 131case MethodKind.StaticConstructor: 132case MethodKind.Conversion: 134case MethodKind.UserDefinedOperator: 135return !method.IsStatic && hidingMember is MethodSymbol { IsStatic: false, MethodKind: MethodKind.UserDefinedOperator }; 137case MethodKind.EventAdd: 138case MethodKind.EventRemove: 139case MethodKind.PropertyGet: 140case MethodKind.PropertySet: 223method.MethodKind is (MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation or MethodKind.PropertyGet or MethodKind.PropertySet or MethodKind.UserDefinedOperator) &&

Symbols\NamedTypeSymbol.cs (5)

217if (candidate is MethodSymbol { MethodKind: MethodKind.UserDefinedOperator or MethodKind.Conversion } method) 278Debug.Assert(method.MethodKind == MethodKind.Constructor); 286Debug.Assert(method.MethodKind == MethodKind.StaticConstructor); 366Debug.Assert(method.MethodKind != MethodKind.ReducedExtension);

Symbols\NativeIntegerTypeSymbol.cs (2)

96case MethodKind.Ordinary: 113case MethodKind.Constructor:

Symbols\OverriddenOrHiddenMembersHelpers.cs (2)

246bool accessorIsGetter = accessor.MethodKind == MethodKind.PropertyGet; 338bool accessorIsAdder = accessor.MethodKind == MethodKind.EventAdd;

Symbols\PublicModel\MethodSymbol.cs (35)

Symbols\ReducedExtensionMethodSymbol.cs (5)

39Debug.Assert(method.IsExtensionMethod && method.MethodKind != MethodKind.ReducedExtension); 74Debug.Assert(method.IsExtensionMethod && method.MethodKind != MethodKind.ReducedExtension); 116Debug.Assert(method.MethodKind != MethodKind.ReducedExtension); 467public override MethodKind MethodKind 469get { return MethodKind.ReducedExtension; }

Symbols\SignatureOnlyMethodSymbol.cs (3)

23private readonly MethodKind _methodKind; 37MethodKind methodKind, 93public override MethodKind MethodKind { get { return _methodKind; } }

Symbols\Source\ExplicitInterfaceHelpers.cs (3)

97if (method.MethodKind != MethodKind.ExplicitInterfaceImplementation) 263(interfaceMethod.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion) != isOperator)

Symbols\Source\LambdaSymbol.cs (2)

75public override MethodKind MethodKind 77get { return MethodKind.AnonymousFunction; }

Symbols\Source\LocalFunctionSymbol.cs (2)

332public override MethodKind MethodKind => MethodKind.LocalFunction;

Symbols\Source\ParameterHelpers.cs (3)

227Debug.Assert(methodOwner?.MethodKind != MethodKind.LambdaMethod); 229methodOwner?.MethodKind == MethodKind.LocalFunction; 1042if (method.MethodKind != MethodKind.AnonymousFunction)

Symbols\Source\SourceComplexParameterSymbol.cs (3)

1341if (!ContainingSymbol.RequiresInstanceReceiver() || ContainingSymbol is MethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.DelegateInvoke or MethodKind.LambdaMethod })

Symbols\Source\SourceConstructorSymbol.cs (13)

25var methodKind = syntax.Modifiers.Any(SyntaxKind.StaticKeyword) ? MethodKind.StaticConstructor : MethodKind.Constructor; 33MethodKind methodKind, 57if (methodKind == MethodKind.Constructor && syntax.Initializer != null) 73if (methodKind == MethodKind.StaticConstructor) 92MethodKind methodKind, 133NamedTypeSymbol containingType, ConstructorDeclarationSyntax syntax, MethodKind methodKind, bool hasBody, Location location, BindingDiagnosticBag diagnostics, 136var defaultAccess = (methodKind == MethodKind.StaticConstructor) ? DeclarationModifiers.None : DeclarationModifiers.Private; 145if (methodKind == MethodKind.Constructor) 154if (methodKind == MethodKind.StaticConstructor) 180private void CheckModifiers(MethodKind methodKind, bool hasBody, Location location, BindingDiagnosticBag diagnostics) 190else if (ContainingType.IsStatic && methodKind == MethodKind.Constructor)

Symbols\Source\SourceConstructorSymbolBase.cs (1)

64if (MethodKind == MethodKind.StaticConstructor && (_lazyParameters.Length != 0) &&

Symbols\Source\SourceDelegateMethodSymbol.cs (5)

26MethodKind methodKind, 217: base(delegateType, voidType, syntax, MethodKind.Constructor, RefKind.None, DeclarationModifiers.Public) 262: base(delegateType, returnType, syntax, MethodKind.DelegateInvoke, refKind, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 355: base((SourceNamedTypeSymbol)invoke.ContainingType, iAsyncResultType, syntax, MethodKind.Ordinary, RefKind.None, DeclarationModifiers.Virtual | DeclarationModifiers.Public) 393: base((SourceNamedTypeSymbol)invoke.ContainingType, invoke.ReturnTypeWithAnnotations, syntax, MethodKind.Ordinary, invoke.RefKind, DeclarationModifiers.Virtual | DeclarationModifiers.Public)

Symbols\Source\SourceDestructorSymbol.cs (1)

68MethodKind.Destructor, RefKind.None, declarationModifiers, returnsVoid: true, returnsVoidIsSet: true,

Symbols\Source\SourceEventAccessorSymbol.cs (6)

36isAdder ? MethodKind.EventAdd : MethodKind.EventRemove, 118if (this.MethodKind == MethodKind.EventAdd) 127Debug.Assert(this.MethodKind == MethodKind.EventRemove); 241? (MethodKind == MethodKind.EventAdd ? other.AddMethod : other.RemoveMethod) 245? (MethodKind == MethodKind.EventAdd ? other.AddMethod : other.RemoveMethod)

Symbols\Source\SourceFieldLikeEventSymbol.cs (1)

261return IsExtern && this.MethodKind == MethodKind.EventAdd

Symbols\Source\SourceMemberContainerSymbol.cs (48)

Symbols\Source\SourceMemberContainerSymbol_ImplementationChecks.cs (2)

553else if (method.MethodKind == MethodKind.Destructor) 892!(overridingMemberIsMethod && ((MethodSymbol)overriddenMember).MethodKind == MethodKind.Destructor)) //destructors are metadata virtual

Symbols\Source\SourceMemberMethodSymbol.cs (13)

126public MethodKind MethodKind 128get { return (MethodKind)((_flags >> MethodKindOffset) & MethodKindMask); } 176Debug.Assert(EnumUtilities.ContainsAllValues<MethodKind>(MethodKindMask)); 188MethodKind methodKind, 234MethodKind methodKind, 352if (this.DeclaredAccessibility <= Accessibility.Private || MethodKind == MethodKind.ExplicitInterfaceImplementation) 357ErrorCode code = (this.MethodKind == MethodKind.Conversion || this.MethodKind == MethodKind.UserDefinedOperator) ? 368code = (this.MethodKind == MethodKind.Conversion || this.MethodKind == MethodKind.UserDefinedOperator) ? 422MethodKind methodKind, 554public sealed override MethodKind MethodKind 1058if ((!IsStatic || MethodKind is MethodKind.StaticConstructor) &&

Symbols\Source\SourceMethodSymbol.cs (1)

238if (target.MethodKind == MethodKind.UserDefinedOperator && !target.IsStatic)

Symbols\Source\SourceMethodSymbolWithAttributes.cs (25)

Symbols\Source\SourceNamedTypeSymbol.cs (1)

1844&& !GetMembers().All(m => m is not MethodSymbol { MethodKind: MethodKind.Constructor, ObsoleteKind: ObsoleteAttributeKind.None } method

Symbols\Source\SourceOrdinaryMethodOrUserDefinedOperatorSymbol.cs (3)

61if (MethodKind == MethodKind.ExplicitInterfaceImplementation) 92if (MethodKind != MethodKind.ExplicitInterfaceImplementation) 198return MethodKind == MethodKind.ExplicitInterfaceImplementation;

Symbols\Source\SourceOrdinaryMethodSymbol.cs (16)

Symbols\Source\SourcePropertyAccessorSymbol.cs (19)

Symbols\Source\SourcePropertySymbolBase.cs (4)

347{ MethodKind: MethodKind.PropertyGet, IsInitOnly: false } => SyntaxFacts.GetText(SyntaxKind.GetKeyword), 348{ MethodKind: MethodKind.PropertySet, IsInitOnly: false } => SyntaxFacts.GetText(SyntaxKind.SetKeyword), 349{ MethodKind: MethodKind.PropertySet, IsInitOnly: true } => SyntaxFacts.GetText(SyntaxKind.InitKeyword), 1200Debug.Assert(thisAccessor.MethodKind == MethodKind.PropertySet);

Symbols\Source\SourceUserDefinedConversionSymbol.cs (4)

42var methodKind = interfaceSpecifier == null 43? MethodKind.Conversion 44: MethodKind.ExplicitInterfaceImplementation; 54MethodKind methodKind,

Symbols\Source\SourceUserDefinedOperatorSymbol.cs (4)

48var methodKind = interfaceSpecifier == null 49? MethodKind.UserDefinedOperator 50: MethodKind.ExplicitInterfaceImplementation; 60MethodKind methodKind,

Symbols\Source\SourceUserDefinedOperatorSymbolBase.cs (5)

25MethodKind methodKind, 48isExplicitInterfaceImplementation: methodKind == MethodKind.ExplicitInterfaceImplementation, 168protected static DeclarationModifiers MakeDeclarationModifiers(bool isCompoundAssignmentOrIncrementAssignment, MethodKind methodKind, SourceMemberContainerTypeSymbol containingType, BaseMethodDeclarationSyntax syntax, Location location, BindingDiagnosticBag diagnostics) 171bool isExplicitInterfaceImplementation = methodKind == MethodKind.ExplicitInterfaceImplementation; 428if (MethodKind == MethodKind.ExplicitInterfaceImplementation)

Symbols\Source\ThisParameterSymbol.cs (1)

157if (_containingMethod?.MethodKind == MethodKind.Constructor)

Symbols\Symbol.cs (14)

Symbols\Symbol_Attributes.cs (4)

57case MethodKind.Constructor: 58case MethodKind.StaticConstructor: 672Debug.Assert(!binder.InAttributeArgument || this is MethodSymbol { MethodKind: MethodKind.LambdaMethod or MethodKind.LocalFunction }, "Possible cycle in attribute binding");

Symbols\SymbolExtensions.cs (5)

150if (method.MethodKind != MethodKind.AnonymousFunction && method.MethodKind != MethodKind.LocalFunction) break; 170if (method.MethodKind == MethodKind.AnonymousFunction || method.MethodKind == MethodKind.LocalFunction) 815=> method is { MethodKind: MethodKind.Constructor, HasSetsRequiredMembers: false };

Symbols\Synthesized\Records\SynthesizedPrimaryConstructor.cs (1)

42MethodKind.Constructor,

Symbols\Synthesized\Records\SynthesizedRecordCopyCtor.cs (1)

135if (member is MethodSymbol { ContainingType.IsRecord: true, MethodKind: MethodKind.Constructor } method)

Symbols\Synthesized\Records\SynthesizedRecordEqualityContractProperty.cs (1)

150MethodKind.PropertyGet,

Symbols\Synthesized\Records\SynthesizedRecordEqualityOperatorBase.cs (1)

39: base(MethodKind.UserDefinedOperator, explicitInterfaceType: null, name, isCompoundAssignmentOrIncrementAssignment: false,

Symbols\Synthesized\Records\SynthesizedRecordOrdinaryMethod.cs (1)

17MethodKind.Ordinary, RefKind.None, declarationModifiers, returnsVoid: false, returnsVoidIsSet: false,

Symbols\Synthesized\SynthesizedAccessorValueParameterSymbol.cs (1)

128if (accessor.MethodKind == MethodKind.EventAdd)

Symbols\Synthesized\SynthesizedDelegateSymbol.cs (2)

93public override MethodKind MethodKind 95get { return MethodKind.DelegateInvoke; }

Symbols\Synthesized\SynthesizedEntryPointSymbol.cs (2)

151public override MethodKind MethodKind 153get { return MethodKind.Ordinary; }

Symbols\Synthesized\SynthesizedEventAccessorSymbol.cs (2)

60return this.MethodKind == MethodKind.EventAdd 146BoundBlock body = CSharp.MethodBodySynthesizer.ConstructFieldLikeEventAccessorBody(fieldLikeEvent, isAddMethod: MethodKind == MethodKind.EventAdd, compilationState.Compilation, diagnostics);

Symbols\Synthesized\SynthesizedExplicitImplementationForwardingMethod.cs (2)

38public override MethodKind MethodKind 44MethodKind.ExplicitInterfaceImplementation;

Symbols\Synthesized\SynthesizedGlobalMethodSymbol.cs (2)

244public override MethodKind MethodKind 246get { return MethodKind.Ordinary; }

Symbols\Synthesized\SynthesizedImplementationMethod.cs (2)

138public override MethodKind MethodKind 142return MethodKind.ExplicitInterfaceImplementation;

Symbols\Synthesized\SynthesizedInstanceConstructor.cs (2)

188public sealed override MethodKind MethodKind 190get { return MethodKind.Constructor; }

Symbols\Synthesized\SynthesizedInteractiveInitializerMethod.cs (2)

129public override MethodKind MethodKind 131get { return MethodKind.Ordinary; }

Symbols\Synthesized\SynthesizedIntrinsicOperatorSymbol.cs (2)

66public override MethodKind MethodKind 70return MethodKind.BuiltinOperator;

Symbols\Synthesized\SynthesizedSealedPropertyAccessor.cs (1)

133public override MethodKind MethodKind

Symbols\Synthesized\SynthesizedSimpleProgramEntryPointSymbol.cs (1)

72MethodKind.Ordinary,

Symbols\Synthesized\SynthesizedStaticConstructor.cs (2)

189public override MethodKind MethodKind 193return MethodKind.StaticConstructor;

Symbols\TypeMap.cs (2)

187stopAt?.MethodKind == MethodKind.StaticConstructor || 188stopAt?.MethodKind == MethodKind.Constructor);

Symbols\TypeSymbol.cs (9)

1579case MethodKind.PropertyGet: 1582case MethodKind.PropertySet: 1585case MethodKind.EventAdd: 1588case MethodKind.EventRemove: 1712else if (implicitImplMethod.IsStatic && implicitImplMethod.MethodKind == MethodKind.Ordinary && implicitImplMethod.GetUnmanagedCallersOnlyAttributeData(forceComplete: true) is not null) 2194isOperator = interfaceMethod.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion; 2202(((MethodSymbol)member).MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion) != isOperator.GetValueOrDefault())

Symbols\Wrapped\WrappedMethodSymbol.cs (1)

280public override MethodKind MethodKind

Microsoft.CodeAnalysis.CSharp.CodeStyle (20)

src\Analyzers\CSharp\Analyzers\MakeStructFieldsWritable\CSharpMakeStructFieldsWritableDiagnosticAnalyzer.cs (1)

87if (context.OwningSymbol is IMethodSymbol { MethodKind: MethodKind.Constructor })

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (4)

175if (owningMethod.MethodKind is not (MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation or MethodKind.PropertyGet or MethodKind.PropertySet)

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

55if (symbol is not IMethodSymbol { MethodKind: MethodKind.Constructor, Parameters: [var constructorParameter] } ||

src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (1)

68MethodKind: MethodKind.Constructor,

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs (2)

79if (method.MethodKind == MethodKind.PropertyGet) 93Debug.Assert(method.MethodKind == MethodKind.Ordinary);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (3)

73method.MethodKind is MethodKind.PropertyGet or MethodKind.Ordinary && 146=> method.MethodKind != MethodKind.Ordinary

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

19conversion.MethodSymbol.MethodKind == MethodKind.Conversion &&

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

372MethodKind: MethodKind.ReducedExtension,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

67if (symbol is IMethodSymbol { MethodKind: MethodKind.Conversion })

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

997if (sym is IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator } op) 1242method.MethodKind is not (MethodKind.LocalFunction or MethodKind.LambdaMethod) && 1412if (originalMemberSymbol is not IMethodSymbol { MethodKind: MethodKind.DelegateInvoke } originalMethodSymbol || 1413rewrittenMemberSymbol is not IMethodSymbol { MethodKind: MethodKind.DelegateInvoke } rewrittenMethodSymbol)

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

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateConversionService.cs (1)

214methodKind: MethodKind.Conversion);

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationService.cs (2)

156if (method.MethodKind == MethodKind.Conversion) 162if (method.MethodKind == MethodKind.UserDefinedOperator)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (2)

2017while (enclosingSymbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction } method)

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

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

241[InlineData("void [|m|]() {}", "void M() {}", MethodKind.Ordinary, Accessibility.Private)] 242[InlineData("void Outer() { void [|m|]() {} }", "void Outer() { void M() {} }", MethodKind.LocalFunction, Accessibility.NotApplicable)]

Microsoft.CodeAnalysis.CSharp.EditorFeatures (1)

EventHookup\EventHookupSessionManager_EventHookupSession.cs (1)

157new SymbolKindOrTypeKind(MethodKind.Ordinary),

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

Completion\CompletionProviders\DeclarationNameCompletionProviderTests.cs (2)

2975SpecificationStyle(new SymbolKindOrTypeKind(MethodKind.Ordinary), "Method"), 2977SpecificationStyle(new SymbolKindOrTypeKind(MethodKind.LocalFunction), "LocalFunction"),

Completion\CompletionProviders\DeclarationNameCompletionProviderTests_NameDeclarationInfoTests.cs (22)

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (4)

98Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 99Assert.False(ideEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid)); 111Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && e.ReturnsVoid)); 112Assert.False(compilerEngineAnalyzer.CallLog.Any(e => e.CallerName == method && e.MethodKind == MethodKind.DelegateInvoke && !e.ReturnsVoid));

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

BreakingChanges.cs (2)

128Assert.Equal(MethodKind.PropertySet, derivedProperty1Synthesized.MethodKind); 131Assert.Equal(MethodKind.PropertyGet, derivedProperty2Synthesized.MethodKind);

CodeGen\CodeGenTupleTest.cs (1)

14341Assert.Equal(MethodKind.ReducedExtension, m6Method.MethodKind);

CodeGen\DestructorTests.cs (1)

824Assert.Equal(MethodKind.Destructor, destructor.MethodKind);

CodeGen\EventTests.cs (2)

216Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind); 222Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind);

CodeGen\IndexerTests.cs (4)

162Assert.Equal(MethodKind.ExplicitInterfaceImplementation, getMethod.MethodKind); //since CallMethodsDirectly 167Assert.Equal(MethodKind.ExplicitInterfaceImplementation, setMethod.MethodKind); //since CallMethodsDirectly 270Assert.Equal(MethodKind.PropertyGet, getMethod.MethodKind); 282Assert.Equal(MethodKind.PropertySet, setMethod.MethodKind);

Emit\CompilationEmitTests.cs (1)

2732var cciMethods = class1TypeDef.GetMethods(context).Where(m => ((MethodSymbol)m.GetInternalSymbol()).MethodKind != MethodKind.Constructor);

Emit\EmitMetadataTests.cs (2)

602Assert.Equal(MethodKind.Constructor, ctor.MethodKind); 623Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind);

Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (16)

Emit\EditAndContinue\SymbolMatcherTests.cs (16)

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

Attributes\AttributeTests_CallerInfoAttributes.cs (2)

4405Assert.Equal(MethodKind.Constructor, ctor.MethodKind); 4435Assert.Equal(MethodKind.Constructor, ctor.MethodKind);

Semantics\ExtensionTests.cs (5)

4759Assert.Equal(MethodKind.Ordinary, implementation.MethodKind); 6214Assert.Equal(MethodKind.Ordinary, implementation.MethodKind); 7689Assert.Equal(MethodKind.Ordinary, implementation.MethodKind); 9195Assert.Equal(MethodKind.Ordinary, implementation.MethodKind); 9484Assert.Equal(MethodKind.Ordinary, implementation.MethodKind);

Semantics\ParamsCollectionTests.cs (1)

8885bool hasBody = p.ContainingSymbol is not MethodSymbol { MethodKind: MethodKind.DelegateInvoke };

Semantics\PrimaryConstructorTests.cs (2)

135Assert.Equal(MethodKind.Constructor, members.Cast<MethodSymbol>().Single().MethodKind); 822Assert.All(c.GetMembers(), m => Assert.True(m is MethodSymbol { MethodKind: MethodKind.Constructor }));

Semantics\RecordTests.cs (1)

22631var ordinaryMethods = comp.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray();

Symbols\UserDefinedCompoundAssignmentOperatorsTests.cs (84)

Microsoft.CodeAnalysis.CSharp.Features (46)

ChangeSignature\CSharpChangeSignatureService.cs (1)

432symbolInfo.Symbol is IMethodSymbol { MethodKind: MethodKind.ReducedExtension },

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

175_ => [new SymbolKindOrTypeKind(SymbolKind.Local), new SymbolKindOrTypeKind(MethodKind.LocalFunction)], 528new SymbolKindOrTypeKind(MethodKind.Ordinary)); 551? [new SymbolKindOrTypeKind(MethodKind.LocalFunction)] : 552[new SymbolKindOrTypeKind(SymbolKind.Local), new SymbolKindOrTypeKind(MethodKind.LocalFunction)];

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

218case MethodKind.Ordinary: 221case MethodKind.UserDefinedOperator: 222case MethodKind.BuiltinOperator: 226case MethodKind.Conversion:

EditAndContinue\CSharpEditAndContinueAnalyzer.cs (13)

ExtractMethod\CSharpMethodExtractor.CSharpCodeGenerator.cs (4)

106methodKind: this.LocalFunction ? MethodKind.LocalFunction : MethodKind.Ordinary); 1156var localFunctionPreferences = Options.NamingStyle.SymbolSpecifications.Where(symbol => symbol.AppliesTo(new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction), CreateMethodModifiers(), null)); 1159var localFunctionKind = new SymbolSpecification.SymbolKindOrTypeKind(MethodKind.LocalFunction);

InitializeParameter\CSharpInitializeMemberFromPrimaryConstructorParameterCodeRefactoringProvider.cs (1)

55if (parameter.ContainingSymbol is not IMethodSymbol { MethodKind: MethodKind.Constructor } constructor)

InlineHints\CSharpInlineTypeHintsService.cs (1)

77if (parameter?.ContainingSymbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } &&

NavigationBar\CSharpNavigationBarItemService.cs (2)

178return method.MethodKind is MethodKind.PropertyGet or MethodKind.PropertySet;

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_DelegateAndFunctionPointerInvoke.cs (1)

64if (invokeMethod.MethodKind == MethodKind.FunctionPointerSignature)

SignatureHelp\InvocationExpressionSignatureHelpProviderBase_MethodGroup.cs (1)

75methodGroup = methodGroup.Where(m => m.IsStatic || m is IMethodSymbol { MethodKind: MethodKind.LocalFunction });

src\Analyzers\CSharp\Analyzers\MakeStructFieldsWritable\CSharpMakeStructFieldsWritableDiagnosticAnalyzer.cs (1)

87if (context.OwningSymbol is IMethodSymbol { MethodKind: MethodKind.Constructor })

src\Analyzers\CSharp\Analyzers\MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs (4)

175if (owningMethod.MethodKind is not (MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation or MethodKind.PropertyGet or MethodKind.PropertySet)

src\Analyzers\CSharp\Analyzers\UseCollectionExpression\CSharpUseCollectionExpressionForNewDiagnosticAnalyzer.cs (1)

55if (symbol is not IMethodSymbol { MethodKind: MethodKind.Constructor, Parameters: [var constructorParameter] } ||

src\Analyzers\CSharp\Analyzers\UseCollectionInitializer\CSharpUseCollectionInitializerAnalyzer.cs (1)

68MethodKind: MethodKind.Constructor,

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\CSharpUseIndexOperatorDiagnosticAnalyzer.InfoCache.cs (2)

79if (method.MethodKind == MethodKind.PropertyGet) 93Debug.Assert(method.MethodKind == MethodKind.Ordinary);

src\Analyzers\CSharp\Analyzers\UseIndexOrRangeOperator\Helpers.cs (3)

73method.MethodKind is MethodKind.PropertyGet or MethodKind.Ordinary && 146=> method.MethodKind != MethodKind.Ordinary

src\Analyzers\CSharp\CodeFixes\GenerateParameterizedMember\CSharpGenerateConversionService.cs (1)

214methodKind: MethodKind.Conversion);

src\Compilers\CSharp\CSharpAnalyzerDriver\CSharpDeclarationComputer.cs (1)

110Debug.Assert(ctor.MethodKind == MethodKind.Constructor && typeDeclaration.ParameterList is object);

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

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

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

Semantics\DelegateTypeTests.cs (3)

902Assert.Equal(MethodKind.LambdaMethod, method.MethodKind); 945Assert.Equal(MethodKind.LambdaMethod, method.MethodKind); 8156Assert.Equal(MethodKind.LambdaMethod, method.MethodKind);

Semantics\InitOnlyMemberTests.cs (1)

2565bool isSetter = method.MethodKind == MethodKind.PropertySet;

Semantics\LambdaTests.cs (5)

857Assert.Equal(MethodKind.AnonymousFunction, (sym as IMethodSymbol).MethodKind); 867Assert.Equal(MethodKind.AnonymousFunction, (sym as IMethodSymbol).MethodKind); 3043Assert.Equal(MethodKind.AnonymousFunction, lambda.MethodKind); 3050Assert.Equal(MethodKind.AnonymousFunction, lambda.MethodKind); 5642Assert.Equal(MethodKind.LambdaMethod, method.MethodKind);

Semantics\LocalFunctionTests.cs (1)

1063Assert.Equal(MethodKind.Constructor, attrConstructor.MethodKind);

Semantics\NamedAndOptionalTests.cs (5)

2047var methods = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray(); 2129var methods = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray(); 2180var methods = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray(); 2263var methods = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray(); 2345var methods = module.GlobalNamespace.GetMember<NamedTypeSymbol>("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind == MethodKind.Ordinary).ToArray();

Semantics\NativeIntegerTests.cs (8)

332case MethodKind.Ordinary: 334case MethodKind.PropertyGet: 335case MethodKind.PropertySet: 350return !(nativeIntegerMember is IMethodSymbol { MethodKind: MethodKind.Constructor }); 446case MethodKind.Ordinary: 448case MethodKind.PropertyGet: 449case MethodKind.PropertySet: 464return !(nativeIntegerMember is MethodSymbol { MethodKind: MethodKind.Constructor });

Semantics\OperatorTests.cs (4)

7618Assert.Equal(MethodKind.BuiltinOperator, symbol1.MethodKind); 8103Assert.Equal(MethodKind.UserDefinedOperator, s.MethodKind); 8291Assert.Equal(MethodKind.UserDefinedOperator, symbol1.MethodKind); 8394Assert.Equal(MethodKind.BuiltinOperator, symbol1.MethodKind);

Semantics\QueryTests.cs (4)

1462Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info0.CastInfo.Symbol).MethodKind); 1471Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info1.OperationInfo.Symbol).MethodKind); 1671Assert.Equal(MethodKind.ReducedExtension, ((IMethodSymbol)info0.CastInfo.Symbol).MethodKind); 1680Assert.Equal(MethodKind.ReducedExtension, ((IMethodSymbol)info1.OperationInfo.Symbol).MethodKind);

Semantics\SimpleLambdaParametersWithModifiersTests.cs (43)

Semantics\TopLevelStatementsTests.cs (1)

4221Assert.Equal(MethodKind.LocalFunction, ((IMethodSymbol)local).MethodKind);

Semantics\UnsafeTests.cs (2)

8873Assert.Equal(MethodKind.BuiltinOperator, summaryMethod.MethodKind); 9335Assert.Equal(MethodKind.BuiltinOperator, summaryMethod.MethodKind);

Semantics\Utf8StringsLiteralsTests.cs (1)

4086Assert.Equal(MethodKind.BuiltinOperator, method.MethodKind);

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

Compilation\GetSemanticInfoTests.cs (7)

1074Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)baseConstructor).MethodKind); 1093Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)baseConstructor).MethodKind); 1116Assert.Equal(MethodKind.Constructor, invokedConstructor.MethodKind); 1172Assert.Equal(MethodKind.EventAdd, ((IMethodSymbol)parameterSymbol.ContainingSymbol).MethodKind); 1201Assert.Equal(MethodKind.EventRemove, ((IMethodSymbol)parameterSymbol.ContainingSymbol).MethodKind); 2360Assert.Equal(MethodKind.AnonymousFunction, ((IMethodSymbol)parameterSymbol.ContainingSymbol).MethodKind); 2542Assert.Equal(MethodKind.Conversion, ((IMethodSymbol)symbol.ContainingSymbol).MethodKind);

Compilation\SemanticModelAPITests.cs (3)

1371Assert.Equal(MethodKind.Constructor, method.MethodKind); 2087Assert.Equal(MethodKind.Constructor, method.MethodKind); 2104Assert.Equal(MethodKind.Constructor, method.MethodKind);

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (10)

354Assert.Equal(MethodKind.PropertyGet, getterSymbol.MethodKind); 360Assert.Equal(MethodKind.PropertySet, setterSymbol.MethodKind); 1722symbol.Kind == SymbolKind.Method && (((IMethodSymbol)symbol).IsExtensionMethod || ((IMethodSymbol)symbol).MethodKind == MethodKind.ReducedExtension); 1885symbol.Kind == SymbolKind.Method && (((IMethodSymbol)symbol).IsExtensionMethod || ((IMethodSymbol)symbol).MethodKind == MethodKind.ReducedExtension); 2854Assert.Equal(MethodKind.ExplicitInterfaceImplementation, explicitMethodSymbol.MethodKind); 2874Assert.Equal(MethodKind.PropertyGet, explicitPropertyGetterSymbol.MethodKind); 2884Assert.Equal(MethodKind.PropertySet, explicitPropertySetterSymbol.MethodKind); 4435Assert.Equal(MethodKind.Conversion, conversion.MethodKind); 4466Assert.Equal(MethodKind.Conversion, conversion.MethodKind); 4497Assert.Equal(MethodKind.UserDefinedOperator, @operator.MethodKind);

Compilation\SemanticModelGetSemanticInfoTests.cs (5)

4881Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)semanticInfo.Symbol.ContainingSymbol).MethodKind); 4888Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)semanticInfo.Symbol.ContainingSymbol).MethodKind); 5408Assert.Equal(MethodKind.PropertySet, ((IMethodSymbol)sortedCandidates[0]).MethodKind); 6368Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)symbol).MethodKind); 7290Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)semanticInfo.Symbol).MethodKind);

DocumentationComments\CrefTests.cs (5)

3230Assert.Equal(MethodKind.Ordinary, ((IMethodSymbol)info.CandidateSymbols[0]).MethodKind); 3278Assert.Equal(MethodKind.Conversion, ((IMethodSymbol)info.CandidateSymbols[0]).MethodKind); 3302Assert.Equal(MethodKind.UserDefinedOperator, ((IMethodSymbol)info.CandidateSymbols[0]).MethodKind); 3326Assert.Equal(MethodKind.Constructor, ((IMethodSymbol)info.CandidateSymbols[0]).MethodKind); 5718Assert.Equal(MethodKind.UserDefinedOperator, ((IMethodSymbol)symbol).MethodKind);

DocumentationComments\DocumentationCommentIDTests.cs (1)

351var method = type.GetMembersUnordered().OfType<MethodSymbol>().Single(m => m.MethodKind == MethodKind.ExplicitInterfaceImplementation);

SymbolDisplay\SymbolDisplayTests.cs (4)

6729Assert.Equal(MethodKind.LocalFunction, localSymbol.MethodKind); 6772Assert.Equal(MethodKind.LocalFunction, localSymbol.MethodKind); 6807Assert.Equal(MethodKind.LocalFunction, localSymbol.MethodKind); 6901Assert.Equal(MethodKind.LocalFunction, localSymbol.MethodKind);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (4)

433Assert.Equal(MethodKind.Ordinary, derivedMethod.MethodKind); 483Assert.Equal(MethodKind.PropertyGet, derivedGetter.MethodKind); 883if (m.MethodKind == MethodKind.Constructor) 887Assert.NotEqual(MethodKind.Ordinary, m.MethodKind);

Symbols\CheckedUserDefinedOperatorsTests.cs (103)

Symbols\ConversionTests.cs (3)

2063var conversionSymbols = destinationType.GetMembers().OfType<IMethodSymbol>().Where(m => m.MethodKind == MethodKind.Conversion); 2144Assert.Equal(MethodKind.Conversion, method.MethodKind); 2178Assert.Equal(MethodKind.Conversion, method.MethodKind);

Symbols\DefaultInterfaceImplementationTests.cs (5)

43953Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind); 44676Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind); 44774Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind); 45242Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind); 45710Assert.Equal(MethodKind.StaticConstructor, cctor.MethodKind);

Symbols\DestructorTests.cs (1)

401Assert.Equal(MethodKind.Destructor, destructor.MethodKind);

Symbols\ExtensionMethodTests.cs (2)

229Assert.Equal(MethodKind.ReducedExtension, gooSymbol.MethodKind); 232Assert.Equal(MethodKind.Ordinary, gooOriginal.MethodKind);

Symbols\InterfaceImplementationTests.cs (25)

Symbols\Metadata\MetadataMemberTests.cs (2)

164Assert.Equal(MethodKind.Constructor, ctor.MethodKind); 205Assert.Equal(MethodKind.Ordinary, member1.MethodKind);

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

98case MethodKind.EventAdd: 101case MethodKind.EventRemove:

Symbols\Metadata\PE\LoadingIndexers.cs (5)

1072Assert.Equal(MethodKind.Ordinary, accessor.MethodKind); 1077Assert.Equal(propertyIsIndexer ? MethodKind.PropertyGet : MethodKind.Ordinary, accessor.MethodKind); 1084Assert.Equal(propertyIsIndexer ? MethodKind.PropertySet : MethodKind.Ordinary, accessor.MethodKind);

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

Symbols\ModuleInitializers\ModuleInitializersTests.cs (1)

133Assert.Equal(MethodKind.StaticConstructor, staticConstructor.MethodKind);

Symbols\RequiredMembersTests.cs (1)

70foreach (var ctor in type.GetMembers().Where(m => m is MethodSymbol { MethodKind: MethodKind.Constructor }))

Symbols\Retargeting\RetargetExplicitInterfaceImplementation.cs (5)

87if (method.MethodKind == MethodKind.ExplicitInterfaceImplementation) 157Assert.Equal(MethodKind.ExplicitInterfaceImplementation, retargetedClassCMethod1.MethodKind); 168Assert.Equal(MethodKind.ExplicitInterfaceImplementation, retargetedClassCMethod2.MethodKind); 177Assert.Equal(MethodKind.ExplicitInterfaceImplementation, retargetedClassCMethod3.MethodKind); 186Assert.Equal(MethodKind.ExplicitInterfaceImplementation, retargetedClassCMethod4.MethodKind);

Symbols\Source\CustomModifierCopyTests.cs (5)

533AssertAllParametersHaveConstModOpt(explicitImpl, ignoreLast: explicitImpl.MethodKind == MethodKind.PropertySet); 738var explicitGetterImpl = explicitImpls.Where(impl => impl.ImplementingMethod.MethodKind == MethodKind.PropertyGet).Single(); 741var explicitSetterImpl = explicitImpls.Where(impl => impl.ImplementingMethod.MethodKind == MethodKind.PropertySet).Single(); 1486m => m.MethodKind == MethodKind.ExplicitInterfaceImplementation); 1530m => m.MethodKind == MethodKind.ExplicitInterfaceImplementation);

Symbols\Source\DeclaringSyntaxNodeTests.cs (2)

159Assert.Equal(MethodKind.AnonymousFunction, sym.MethodKind); 523if (memb.Kind == SymbolKind.Method && ((IMethodSymbol)memb).MethodKind == MethodKind.Constructor)

Symbols\Source\DelegateTests.cs (1)

112Assert.Equal(MethodKind.DelegateInvoke, invoke.MethodKind);

Symbols\Source\EventTests.cs (8)

89Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind); 94Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind); 127Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind); 132Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind); 166Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind); 171Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind); 201Assert.Equal(MethodKind.EventAdd, addMethod.MethodKind); 206Assert.Equal(MethodKind.EventRemove, removeMethod.MethodKind);

Symbols\Source\MethodTests.cs (8)

Symbols\Source\NullablePublicAPITests.cs (4)

3491Assert.Equal(MethodKind.LambdaMethod, lambdaSymbol.MethodKind); 3544Assert.Equal(MethodKind.LambdaMethod, innerLambdaSymbol.MethodKind); 3605Assert.Equal(MethodKind.LambdaMethod, innerLambdaSymbol.MethodKind); 4131var localFunctionResult = lookupResults.OfType<IMethodSymbol>().First(m => m.MethodKind == MethodKind.LocalFunction);

Symbols\Source\PropertyTests.cs (20)

Symbols\Source\RecordTests.cs (2)

153Assert.Equal(MethodKind.PropertyGet, x.GetMethod!.MethodKind); 187Assert.Equal(MethodKind.PropertyGet, y.GetMethod!.MethodKind);

Symbols\StaticAbstractMembersInInterfacesTests.cs (122)

Symbols\TypeTests.cs (2)

1205.Count(m => !(m is MethodSymbol) || (m as MethodSymbol).MethodKind != MethodKind.Constructor)); 2466var method = typeMembers.OfType<MethodSymbol>().First(m => m is { MethodKind: not MethodKind.Constructor });

Symbols\UnsignedRightShiftTests.cs (12)

1988Assert.Equal(MethodKind.UserDefinedOperator, compilation1.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 1997Assert.Equal(MethodKind.UserDefinedOperator, compilation2.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 2003Assert.Equal(MethodKind.UserDefinedOperator, compilation3.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 2240Assert.Equal(MethodKind.UserDefinedOperator, compilation1.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 2249Assert.Equal(MethodKind.UserDefinedOperator, compilation2.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 2255Assert.Equal(MethodKind.UserDefinedOperator, compilation3.GetMember<MethodSymbol>("C1.op_UnsignedRightShift").MethodKind); 2706var expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First(); 2724expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First(); 2732expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First(); 2875var expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First(); 2893expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First(); 2901expectedSymbol = compilation.SourceModule.GlobalNamespace.GetTypeMember("C").GetMembers().OfType<MethodSymbol>().Where(m => m.MethodKind != MethodKind.Constructor).First();

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

Syntax\LambdaUtilitiesTests.cs (1)

49bool expected = enclosingMethod.MethodKind == MethodKind.LambdaMethod && enclosingSyntax.Span.Contains(span.Value);

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

CSharpTrackingDiagnosticAnalyzer.cs (2)

22protected override bool IsOnCodeBlockSupported(SymbolKind symbolKind, MethodKind methodKind, bool returnsVoid) 24return base.IsOnCodeBlockSupported(symbolKind, methodKind, returnsVoid) && methodKind != MethodKind.EventRaise;

Extensions.cs (5)

575case MethodKind.EventAdd: 576case MethodKind.EventRemove: 580case MethodKind.PropertyGet: 581case MethodKind.PropertySet: 583var isSetter = accessor.MethodKind == MethodKind.PropertySet;

FunctionPointerUtilities.cs (1)

58Assert.Equal(MethodKind.FunctionPointerSignature, symbol.MethodKind);

Microsoft.CodeAnalysis.CSharp.Workspaces (17)

Classification\SyntaxClassification\NameSyntaxClassifier.cs (2)

256if (methodSymbol.MethodKind == MethodKind.Constructor) 262if (methodSymbol.MethodKind == MethodKind.ReducedExtension)

Classification\SyntaxClassification\OperatorOverloadSyntaxClassifier.cs (1)

48if (symbolInfo.Symbol is IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator })

Recommendations\CSharpRecommendationServiceRunner.cs (1)

768if (symbol is IMethodSymbol { MethodKind: MethodKind.AnonymousFunction })

Recommendations\CSharpRecommendationServiceRunner_Operators.cs (1)

33if (member is not IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator } method)

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

19conversion.MethodSymbol.MethodKind == MethodKind.Conversion &&

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

372MethodKind: MethodKind.ReducedExtension,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\CSharp\Services\SemanticFacts\CSharpSemanticFacts.cs (1)

67if (symbol is IMethodSymbol { MethodKind: MethodKind.Conversion })

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

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\CodeGeneration\CSharpCodeGenerationService.cs (2)

156if (method.MethodKind == MethodKind.Conversion) 162if (method.MethodKind == MethodKind.UserDefinedOperator)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\CSharp\Extensions\ContextQuery\SyntaxTreeExtensions.cs (2)

2017while (enclosingSymbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction } method)

Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (3)

CodeGeneration\SyntaxGeneratorTests.cs (3)

1079var op = c.GetMembers().OfType<IMethodSymbol>().Where(m => m.MethodKind == MethodKind.Conversion).Single(); 2577var method = type.GetMembers().Single(m => m is IMethodSymbol { MethodKind: MethodKind.ExplicitInterfaceImplementation }); 4360var method = symbolC.GetMembers().OfType<IMethodSymbol>().Single(m => m.MethodKind == MethodKind.Ordinary);

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (2)

Utilities\SymbolEquivalenceComparerTests.cs (2)

1870Assert.Equal(MethodKind.ReducedExtension, method1.MethodKind); 1873Assert.Equal(MethodKind.ReducedExtension, method2.MethodKind);

Microsoft.CodeAnalysis.Features (89)

ChangeSignature\AbstractChangeSignatureService.cs (3)

271if (methodSymbol is { MethodKind: MethodKind.PropertyGet or MethodKind.PropertySet }) 311if (methodSymbol.MethodKind == MethodKind.DelegateInvoke)

ChangeSignature\DelegateInvokeMethodReferenceFinder.cs (1)

38=> symbol.MethodKind == MethodKind.DelegateInvoke;

CodeLens\CodeLensFindReferenceProgress.cs (1)

122(definition as IMethodSymbol)?.MethodKind == MethodKind.Constructor;

CodeLens\CodeLensReferencesService.cs (1)

236if (method.MethodKind != MethodKind.AnonymousFunction)

Completion\Providers\AbstractContextVariableArgumentProvider.cs (2)

90while (enclosingSymbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction })

ConvertAnonymousType\AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs (3)

352var getMethod = prop.GetMethod != null ? CreateAccessorSymbol(prop, MethodKind.PropertyGet) : null; 353var setMethod = prop.SetMethod != null ? CreateAccessorSymbol(prop, MethodKind.PropertySet) : null; 370private static IMethodSymbol CreateAccessorSymbol(IPropertySymbol prop, MethodKind kind)

ConvertToInterpolatedString\AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs (1)

293MethodKind: MethodKind.BuiltinOperator,

Debugging\AbstractDataTipInfoGetter.cs (1)

47MethodKind: MethodKind.ReducedExtension,

DocumentHighlighting\AbstractDocumentHighlightsService.cs (6)

144case MethodKind.AnonymousFunction: 145case MethodKind.PropertyGet: 146case MethodKind.PropertySet: 147case MethodKind.EventAdd: 148case MethodKind.EventRaise: 149case MethodKind.EventRemove:

EditAndContinue\AbstractEditAndContinueAnalyzer.cs (9)

351MethodKind.Constructor => FeaturesResources.constructor, 352MethodKind.PropertyGet or MethodKind.PropertySet => FeaturesResources.property_accessor, 353MethodKind.EventAdd or MethodKind.EventRaise or MethodKind.EventRemove => FeaturesResources.event_accessor, 354MethodKind.BuiltinOperator or MethodKind.UserDefinedOperator or MethodKind.Conversion => FeaturesResources.operator_,

EmbeddedLanguages\DateAndTime\LanguageServices\DateAndTimeLanguageDetector.cs (1)

151method.MethodKind == MethodKind.Ordinary &&

ExtractMethod\Extensions.cs (1)

21if (methodSymbol?.MethodKind != MethodKind.AnonymousFunction)

GenerateEqualsAndGetHashCodeFromMembers\GenerateEqualsAndGetHashCodeFromMembersCodeRefactoringProvider.cs (1)

130.Any(m => m.MethodKind == MethodKind.UserDefinedOperator &&

GoToBase\AbstractGoToBaseService.cs (1)

45if (bases.Length == 0 && symbol is IMethodSymbol { MethodKind: MethodKind.Constructor } constructor)

InheritanceMargin\AbstractInheritanceMarginService.cs (4)

78MethodKind: MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation or MethodKind.UserDefinedOperator or MethodKind.Conversion

InitializeParameter\AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs (1)

67if (method.MethodKind != MethodKind.Constructor)

InlineHints\AbstractInlineParameterNameHintsService.cs (2)

231if (parameter is not { ContainingSymbol: IMethodSymbol { MethodKind: MethodKind.Ordinary or MethodKind.LocalFunction } method })

IntroduceParameter\AbstractIntroduceParameterCodeRefactoringProvider.cs (6)

83var methodKind = methodSymbol.MethodKind; 84if (methodKind is not (MethodKind.Ordinary or MethodKind.LocalFunction or MethodKind.Constructor)) 159if (methodSymbol.MethodKind is not MethodKind.Constructor) 170if (methodSymbol.MethodKind is not MethodKind.LocalFunction)

LanguageServiceIndexFormat\SymbolMoniker.cs (1)

33if (symbol is IMethodSymbol method && method.MethodKind == MethodKind.BuiltinOperator)

LanguageServices\SymbolDisplayService\AbstractSymbolDisplayService.AbstractSymbolDescriptionBuilder.cs (1)

629var extension = method.IsExtensionMethod || method.MethodKind == MethodKind.ReducedExtension;

MetadataAsSource\AbstractMetadataAsSourceService.WrappedMethodSymbol.cs (1)

50public MethodKind MethodKind => _symbol.MethodKind;

PullMemberUp\MemberAndDestinationValidator.cs (1)

46IMethodSymbol methodSymbol => methodSymbol.MethodKind == MethodKind.Ordinary,

Rename\SymbolicRenameInfo.cs (1)

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

RQName\RQNodeBuilder.cs (8)

200if (symbol.MethodKind is MethodKind.UserDefinedOperator or 201MethodKind.BuiltinOperator or 202MethodKind.EventAdd or 203MethodKind.EventRemove or 204MethodKind.PropertySet or 205MethodKind.PropertyGet) 212if (symbol.MethodKind == MethodKind.Constructor) 216else if (symbol.MethodKind == MethodKind.Destructor)

Shared\Extensions\ISymbolExtensions_2.cs (9)

99if (methodSymbol.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion or MethodKind.BuiltinOperator) 104methodSymbol.MethodKind == MethodKind.ReducedExtension || 253case MethodKind.EventAdd: 254case MethodKind.EventRaise: 255case MethodKind.EventRemove: 256case MethodKind.PropertyGet: 257case MethodKind.PropertySet:

src\Analyzers\Core\Analyzers\Helpers\DeserializationConstructorCheck.cs (1)

19methodSymbol.MethodKind == MethodKind.Constructor &&

src\Analyzers\Core\Analyzers\QualifyMemberAccess\AbstractQualifyMemberAccessDiagnosticAnalyzer.cs (1)

146return symbol == null || symbol.IsStatic || symbol is IMethodSymbol { MethodKind: MethodKind.LocalFunction };

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

790/// 4. If method, then it is a constructor OR a method with <see cref="MethodKind.Ordinary"/>, 812case MethodKind.Constructor: 842case MethodKind.Ordinary:

src\Analyzers\Core\Analyzers\RemoveUnusedParametersAndValues\AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs (1)

298if (method.MethodKind != MethodKind.Constructor)

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

292if (((IMethodSymbol)symbolInfo.Symbol).MethodKind == MethodKind.LocalFunction)

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

138var isConstructorInitializer = candidates.All(m => m.MethodKind == MethodKind.Constructor);

src\Analyzers\Core\CodeFixes\AddParameter\AddParameterService.cs (3)

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateConversionService.State.cs (2)

59MethodKind = MethodKind.Conversion; 83MethodKind = MethodKind.Conversion;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateDeconstructMethodService.State.cs (1)

54MethodKind = MethodKind.Ordinary;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateMethodService.State.cs (2)

85MethodKind = MethodKind.Ordinary; 124MethodKind = MethodKind.Ordinary;

src\Analyzers\Core\CodeFixes\GenerateParameterizedMember\AbstractGenerateParameterizedMemberService.State.cs (1)

42public MethodKind MethodKind { get; internal set; }

src\Analyzers\Core\CodeFixes\ImplementInterface\ImplementInterfaceGenerator.cs (2)

370return method1.MethodKind == MethodKind.Ordinary && 371method2.MethodKind == MethodKind.Ordinary &&

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

Microsoft.CodeAnalysis.LanguageServer (1)

Services\LspExtractClassOptionsService.cs (1)

29IMethodSymbol methodSymbol => methodSymbol.MethodKind == MethodKind.Ordinary,

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

Options\SolutionAnalyzerConfigOptionsUpdaterTests.cs (2)

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

Microsoft.CodeAnalysis.PublicApiAnalyzers (38)

DeclarePublicApiAnalyzer.Impl.cs (13)

68private static readonly ImmutableArray<MethodKind> s_ignorableMethodKinds 69= ImmutableArray.Create(MethodKind.EventAdd, MethodKind.EventRemove); 204if (method.MethodKind is not (MethodKind.PropertyGet or MethodKind.PropertySet) || 205method is { MethodKind: MethodKind.PropertyGet or MethodKind.PropertySet, AssociatedSymbol.IsImplicitlyDeclared: true }) 310method.MethodKind == MethodKind.Constructor && 558if (sibling is not IMethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.PropertyGet or MethodKind.PropertySet }) 789if (methodSymbol is { MethodKind: MethodKind.Constructor, ContainingType.TypeKind: TypeKind.Enum }) 794if (methodSymbol is { ContainingType.TypeKind: TypeKind.Delegate, MethodKind: not MethodKind.DelegateInvoke })

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (2)

11public const MethodKind LocalFunction = (MethodKind)17;

Microsoft.CodeAnalysis.ResxSourceGenerator (29)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (6)

Microsoft.CodeAnalysis.Test.Utilities (25)

Compilation\CompilationExtensions.cs (2)

383if ((parameterInitializerOperation.Parameter.ContainingSymbol as IMethodSymbol)?.MethodKind is not (MethodKind.LocalFunction or MethodKind.AnonymousFunction))

Compilation\ControlFlowGraphVerifier.cs (2)

1716if (method.MethodKind == MethodKind.LocalFunction) 1731if (method.MethodKind == MethodKind.LocalFunction)

Compilation\TestOperationVisitor.cs (1)

810if (method.MethodKind == MethodKind.BuiltinOperator)

Diagnostics\FieldCouldBeReadOnlyAnalyzer.cs (2)

48bool inConstructor = containingMethod.MethodKind == MethodKind.Constructor; 49ITypeSymbol staticConstructorType = containingMethod.MethodKind == MethodKind.StaticConstructor ? containingMethod.ContainingType : null;

Diagnostics\TrackingDiagnosticAnalyzer.cs (18)

Microsoft.CodeAnalysis.VisualBasic (534)

Analysis\FlowAnalysis\AbstractFlowPass.vb (2)

1226Debug.Assert(method.Kind <> MethodKind.Constructor) 1297Debug.Assert(method.Kind <> MethodKind.Constructor)

Analysis\FlowAnalysis\DataFlowPass.vb (18)

Analysis\InitializerRewriter.vb (1)

273If methodSymbol.MethodKind = MethodKind.Constructor Then

Binding\Binder_Delegates.vb (2)

1147Debug.Assert(delegateInvoke.MethodKind = MethodKind.DelegateInvoke) 1238If method.MethodKind = MethodKind.DelegateInvoke AndAlso

Binding\Binder_Expressions.vb (7)

1872Dim containingMethodKind As MethodKind = Me.KindOfContainingMethodAtRunTime() 1874If containingMethodKind = MethodKind.Constructor Then 1878ElseIf containingMethodKind = MethodKind.SharedConstructor Then 1902Private Function KindOfContainingMethodAtRunTime() As MethodKind 1914Return MethodKind.SharedConstructor 1916Return MethodKind.Constructor 1928Return MethodKind.Ordinary ' Looks like a good default.

Binding\Binder_Invocation.vb (2)

58If Me.ContainingMember.Kind = SymbolKind.Method AndAlso DirectCast(Me.ContainingMember, MethodSymbol).MethodKind = MethodKind.Constructor Then 716Return methodGroup.Methods(0).MethodKind = MethodKind.Constructor

Binding\Binder_Lambda.vb (3)

727Dim containingMethodKind As MethodKind = binderForExpressionContainingLambda.KindOfContainingMethodAtRunTime() 730Case MethodKind.SharedConstructor, MethodKind.Constructor

Binding\Binder_Lookup.vb (1)

1963containingMethod.MethodKind = MethodKind.Constructor AndAlso

Binding\Binder_Statements.vb (8)

Binding\Binder_Utils.vb (22)

Binding\Binder_XmlLiterals.vb (1)

1922Public Overrides ReadOnly Property MethodKind As MethodKind

Binding\DocumentationCommentCrefBinder.vb (27)

Binding\SyntheticBoundTrees\SynthesizedPropertyAccessorBase.vb (2)

72If accessor.MethodKind = MethodKind.PropertyGet Then 88Debug.Assert(accessor.MethodKind = MethodKind.PropertySet)

BoundTree\BoundCall.vb (1)

80Dim isOperator As Boolean = (Method.MethodKind = MethodKind.UserDefinedOperator)

BoundTree\BoundUserDefinedBinaryOperator.vb (1)

41Debug.Assert(underlyingCall.Method.MethodKind = MethodKind.UserDefinedOperator AndAlso underlyingCall.Method.ParameterCount = 2)

BoundTree\BoundUserDefinedConversion.vb (1)

62Debug.Assert(underlyingCall.Method.MethodKind = MethodKind.Conversion AndAlso underlyingCall.Method.ParameterCount = 1)

BoundTree\BoundUserDefinedUnaryOperator.vb (1)

33Debug.Assert(underlyingCall.Method.MethodKind = MethodKind.UserDefinedOperator AndAlso underlyingCall.Method.ParameterCount = 1)

CodeGen\EmitAddress.vb (2)

279Return Me._method.MethodKind = MethodKind.SharedConstructor 281Return Me._method.MethodKind = MethodKind.Constructor AndAlso

Compilation\ClsComplianceChecker.vb (5)

217Dim methodKind As MethodKind = symbol.MethodKind 219Case MethodKind.PropertyGet, MethodKind.PropertySet 232Case MethodKind.EventAdd, MethodKind.EventRemove

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

725Return If(method.MethodKind = MethodKind.DeclareMethod, "declare", 726If(method.MethodKind = MethodKind.UserDefinedOperator OrElse method.MethodKind = MethodKind.Conversion, "operator",

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

108Me.IsDeclareMethod = method.MethodKind = MethodKind.DeclareMethod 112Me.TypeParamSupported = Not Me.IsDeclareMethod AndAlso method.MethodKind <> MethodKind.UserDefinedOperator

Compilation\DocumentationComments\DocumentationCommentCompiler.Method.vb (3)

92If method.MethodKind = MethodKind.DeclareMethod Then 106If method.MethodKind = MethodKind.UserDefinedOperator OrElse method.MethodKind = MethodKind.DeclareMethod Then

Compilation\MethodCompiler.vb (10)

Compilation\SemanticModel.vb (1)

1867(result.Kind = SymbolKind.Method AndAlso DirectCast(result, MethodSymbol).MethodKind = MethodKind.Constructor) Then

DocumentationComments\DocumentationCommentIDVisitor.PartVisitor.vb (1)

86If symbol.MethodKind = MethodKind.Conversion Then

Emit\MethodSymbolAdapter.vb (3)

307Return AdaptedMethodSymbol.MethodKind = MethodKind.Constructor 547Dim result = Me.MethodKind = MethodKind.Constructor OrElse 548Me.MethodKind = MethodKind.SharedConstructor

Emit\NamedTypeSymbolAdapter.vb (1)

481If handledEvent.hookupMethod.MethodKind = MethodKind.SharedConstructor Then

Emit\NoPia\EmbeddedMethod.vb (1)

55Return UnderlyingMethod.AdaptedMethodSymbol.MethodKind = MethodKind.Constructor

Emit\SynthesizedPrivateImplementationDetailsSharedConstructor.vb (2)

56Public Overrides ReadOnly Property MethodKind As MethodKind 58Return MethodKind.SharedConstructor

Lowering\Diagnostics\DiagnosticsPass.vb (1)

109If _containingSymbol.MethodKind = MethodKind.LambdaMethod Then

Lowering\ExpressionLambdaRewriter\ExpressionLambdaRewriter.vb (1)

391If method.MethodKind = MethodKind.DelegateInvoke Then

Lowering\ExpressionLambdaRewriter\ExpressionLambdaRewriter_BinaryOperator.vb (2)

270Debug.Assert(helper.MethodKind = MethodKind.Ordinary OrElse helper.MethodKind = MethodKind.UserDefinedOperator)

Lowering\LambdaRewriter\LambdaFrameConstructor.vb (2)

23Public Overrides ReadOnly Property MethodKind As MethodKind 25Return MethodKind.Constructor

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

404If _currentParent.MethodKind <> MethodKind.LambdaMethod Then 431Loop While parent.MethodKind = MethodKind.LambdaMethod AndAlso parent IsNot container

Lowering\LambdaRewriter\LambdaRewriter.vb (4)

563If _innermostFramePointer.Kind = SymbolKind.Parameter AndAlso _topLevelMethod.MethodKind = MethodKind.Constructor AndAlso 1209(closureKind = ClosureKind.Static AndAlso CurrentMethod.MethodKind <> MethodKind.SharedConstructor AndAlso Not referencedMethod.IsGenericMethod) 1419If node.Method.MethodKind = MethodKind.Constructor AndAlso receiver IsNot Nothing AndAlso receiver.IsInstanceReference Then 1466If method.MethodKind = MethodKind.DelegateInvoke AndAlso

Lowering\LocalRewriter\LocalRewriter_BinaryOperators.vb (1)

197If boundCall.Method.MethodKind = MethodKind.PropertyGet AndAlso

Lowering\LocalRewriter\LocalRewriter_Constant.vb (2)

46If currentMethod.MethodKind <> MethodKind.SharedConstructor OrElse 146(currentMethod.MethodKind <> MethodKind.SharedConstructor OrElse

Lowering\LocalRewriter\LocalRewriter_Conversion.vb (2)

978If memberSymbol.MethodKind = MethodKind.Constructor Then 1117If memberSymbol.MethodKind = MethodKind.Constructor Then

Lowering\LocalRewriter\LocalRewriter_LateAddressOf.vb (1)

36Debug.Assert(delegateInvoke.MethodKind = MethodKind.DelegateInvoke)

Lowering\LocalRewriter\LocalRewriter_RaiseEvent.vb (1)

160Dim accessorName As String = Binder.GetAccessorName(invocationListProperty.Name, MethodKind.PropertyGet, isWinMd:=False)

Semantics\Conversions.vb (1)

4177Debug.Assert(toDelegateInvokeMethod.MethodKind = MethodKind.DelegateInvoke)

Semantics\Operators.vb (29)

Semantics\OverloadResolution.vb (2)

971possiblyConstructor.MethodKind = MethodKind.Constructor AndAlso 3754DirectCast(candidate.Candidate.UnderlyingSymbol, MethodSymbol).MethodKind = MethodKind.Constructor AndAlso

SymbolDisplay\SymbolDisplayVisitor.Members.vb (40)

170If symbol.MethodKind = MethodKind.ReducedExtension AndAlso Format.ExtensionMethodStyle = SymbolDisplayExtensionMethodStyle.StaticMethod Then 172ElseIf symbol.MethodKind <> MethodKind.ReducedExtension AndAlso Format.ExtensionMethodStyle = SymbolDisplayExtensionMethodStyle.InstanceMethod Then 197Case MethodKind.Constructor, MethodKind.StaticConstructor 201Case MethodKind.PropertyGet 212Case MethodKind.PropertySet 223Case MethodKind.EventAdd, 224MethodKind.EventRemove, 225MethodKind.EventRaise 233symbol.MethodKind = MethodKind.EventAdd, 236symbol.MethodKind = MethodKind.EventRemove, 244Case MethodKind.Conversion 259Case MethodKind.UserDefinedOperator, MethodKind.BuiltinOperator 270Case MethodKind.Ordinary, 271MethodKind.DelegateInvoke, 272MethodKind.ReducedExtension, 273MethodKind.AnonymousFunction 296If symbol.MethodKind = MethodKind.ReducedExtension Then 311Case MethodKind.Ordinary, MethodKind.DelegateInvoke, MethodKind.DeclareMethod 314Case MethodKind.ReducedExtension 319Case MethodKind.PropertyGet, 320MethodKind.PropertySet, 321MethodKind.EventAdd, 322MethodKind.EventRemove, 323MethodKind.EventRaise 338Case MethodKind.Constructor, MethodKind.StaticConstructor 345Case MethodKind.UserDefinedOperator, MethodKind.BuiltinOperator 361Case MethodKind.Conversion 370Case MethodKind.AnonymousFunction 383If symbol.MethodKind = MethodKind.BuiltinOperator Then 427AddParametersIfRequired(isExtensionMethod:=method.IsExtensionMethod AndAlso method.MethodKind <> MethodKind.ReducedExtension, 436Case MethodKind.Constructor, 437MethodKind.StaticConstructor 687Return vbMethod IsNot Nothing AndAlso vbMethod.MethodKind = MethodKind.DeclareMethod 701DirectCast(symbol, IMethodSymbol).MethodKind = MethodKind.AnonymousFunction OrElse

Symbols\AnonymousTypes\PublicSymbols\AnonymousType_PropertyPublicAccessors.vb (4)

57Public Overrides ReadOnly Property MethodKind As MethodKind 59Return MethodKind.PropertyGet 89Public Overrides ReadOnly Property MethodKind As MethodKind 91Return MethodKind.PropertySet

Symbols\AnonymousTypes\SynthesizedSymbols\AnonymousType_PropertyAccessors.vb (4)

76Public Overrides ReadOnly Property MethodKind As MethodKind 78Return MethodKind.PropertyGet 108Public Overrides ReadOnly Property MethodKind As MethodKind 110Return MethodKind.PropertySet

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

232Dim methKind As MethodKind = DirectCast(symbol, MethodSymbol).MethodKind 234Case MethodKind.PropertyGet, MethodKind.PropertySet 239Case MethodKind.Ordinary, 240MethodKind.Constructor, 241MethodKind.SharedConstructor 288Case MethodKind.SharedConstructor, 289MethodKind.Constructor 372Debug.Assert(kind = MethodKind.Constructor OrElse 373kind = MethodKind.SharedConstructor OrElse 374kind = MethodKind.Ordinary OrElse 375kind = MethodKind.PropertyGet OrElse 376kind = MethodKind.PropertySet)

Symbols\ErrorMethodSymbol.vb (2)

190Public Overrides ReadOnly Property MethodKind As MethodKind 192Return MethodKind.Ordinary

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

90Me._addMethod.SetAssociatedEvent(Me, MethodKind.EventAdd) 94Me._removeMethod.SetAssociatedEvent(Me, MethodKind.EventRemove) 98Me._raiseMethod.SetAssociatedEvent(Me, MethodKind.EventRaise)

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

Symbols\Metadata\PE\PEPropertySymbol.vb (2)

129_getMethod.SetAssociatedProperty(Me, MethodKind.PropertyGet) 133_setMethod.SetAssociatedProperty(Me, MethodKind.PropertySet)

Symbols\MethodKindExtensions.vb (6)

14Friend Function TryGetAccessorDisplayName(kind As MethodKind) As String 16Case MethodKind.EventAdd 19Case MethodKind.EventRaise 22Case MethodKind.EventRemove 25Case MethodKind.PropertyGet 28Case MethodKind.PropertySet

Symbols\MethodSymbol.vb (11)

23Public MustOverride ReadOnly Property MethodKind As MethodKind 32Return Me.ParameterCount = 0 AndAlso Me.MethodKind = MethodKind.Constructor 230Me.MethodKind <> MethodKind.PropertySet AndAlso 323Return DirectCast(Me.AssociatedSymbol, PropertySymbol).GetAccessorOverride(getter:=(MethodKind = MethodKind.PropertyGet)) 426Return IsExtensionMethod AndAlso MethodKind <> MethodKind.ReducedExtension 457Case MethodKind.Ordinary, 458MethodKind.Constructor, 459MethodKind.UserDefinedOperator, 460MethodKind.ReducedExtension 496Return Me.MethodKind = MethodKind.Constructor AndAlso Me.ContainingType.IsScriptClass 953Private ReadOnly Property IMethodSymbol_MethodKind As MethodKind Implements IMethodSymbol.MethodKind

Symbols\MethodSymbolExtensions.vb (2)

86Case MethodKind.UserDefinedOperator, MethodKind.Conversion

Symbols\NamedTypeSymbol.vb (2)

423Debug.Assert(method.MethodKind = MethodKind.Constructor) 431Debug.Assert(method.MethodKind = MethodKind.StaticConstructor)

Symbols\ObsoleteAttributeHelpers.vb (1)

163Dim accessorString = If(accessorSymbol.MethodKind = MethodKind.PropertyGet, "Get", "Set")

Symbols\PropertySymbol.vb (1)

172If If(TryCast(containingMember, MethodSymbol)?.MethodKind <> MethodKind.Constructor, True) Then

Symbols\ReducedExtensionMethodSymbol.vb (4)

49possiblyExtensionMethod.MethodKind <> MethodKind.ReducedExtension) Then 185If Not possiblyExtensionMethod.IsExtensionMethod OrElse possiblyExtensionMethod.MethodKind = MethodKind.ReducedExtension Then 353Public Overrides ReadOnly Property MethodKind As MethodKind 355Return MethodKind.ReducedExtension

Symbols\Retargeting\RetargetingMethodSymbol.vb (1)

438Public Overrides ReadOnly Property MethodKind As MethodKind

Symbols\SignatureOnlyMethodSymbol.vb (3)

23Private ReadOnly _methodKind As MethodKind 34Public Sub New(ByVal name As String, ByVal m_containingType As TypeSymbol, ByVal methodKind As MethodKind, ByVal callingConvention As CallingConvention, ByVal typeParameters As ImmutableArray(Of TypeParameterSymbol), ByVal parameters As ImmutableArray(Of ParameterSymbol), 124Public Overrides ReadOnly Property MethodKind() As MethodKind

Symbols\Source\CustomEventAccessorSymbol.vb (6)

56If Me.MethodKind = MethodKind.EventRaise Then 143Return Not (Me.MethodKind = MethodKind.EventAdd AndAlso _event.IsWindowsRuntimeEvent) 167If(Me.MethodKind = MethodKind.EventRaise, 174If Me.MethodKind = MethodKind.EventRaise Then 214If Me.MethodKind = MethodKind.EventAdd Then 220Debug.Assert(Me.MethodKind = MethodKind.EventRemove)

Symbols\Source\LambdaSymbol.vb (2)

276Public Overrides ReadOnly Property MethodKind As MethodKind 278Return MethodKind.LambdaMethod

Symbols\Source\LocalSymbol.vb (1)

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

Symbols\Source\OverrideHidingHelper.vb (17)

497Case MethodKind.LambdaMethod, MethodKind.Constructor, MethodKind.SharedConstructor 499Case MethodKind.Conversion, MethodKind.DelegateInvoke, MethodKind.UserDefinedOperator, MethodKind.Ordinary, MethodKind.DeclareMethod, 500MethodKind.EventAdd, MethodKind.EventRaise, MethodKind.EventRemove, 501MethodKind.PropertyGet, MethodKind.PropertySet 626(DirectCast(DirectCast(overridingSym, Symbol), MethodSymbol).MethodKind = MethodKind.PropertyGet OrElse 627DirectCast(DirectCast(overridingSym, Symbol), MethodSymbol).MethodKind = MethodKind.PropertySet))) 688(DirectCast(DirectCast(overridingSym, Symbol), MethodSymbol).MethodKind = MethodKind.PropertyGet OrElse 689DirectCast(DirectCast(overridingSym, Symbol), MethodSymbol).MethodKind = MethodKind.PropertySet)))

Symbols\Source\SourceDeclareMethodSymbol.vb (1)

36Debug.Assert(MyBase.MethodKind = MethodKind.DeclareMethod)

Symbols\Source\SourceDelegateMethodSymbol.vb (1)

198Return Me.MethodKind = MethodKind.Constructor

Symbols\Source\SourceEventSymbol.vb (7)

104Case MethodKind.EventAdd 111Case MethodKind.EventRemove 118Case MethodKind.EventRaise 388Friend Function GetAccessorImplementations(kind As MethodKind) As ImmutableArray(Of MethodSymbol) 402Case MethodKind.EventAdd 404Case MethodKind.EventRemove 406Case MethodKind.EventRaise

Symbols\Source\SourceMemberContainerTypeSymbol.vb (19)

Symbols\Source\SourceMemberMethodSymbol.vb (1)

107If MethodKind = MethodKind.Ordinary Then

Symbols\Source\SourceMethodSymbol.vb (30)

629Public Overrides ReadOnly Property MethodKind As MethodKind 1274Debug.Assert(Me.MethodKind <> MethodKind.EventAdd, 1499If Not (Me.MethodKind <> MethodKind.Ordinary AndAlso Me.MethodKind <> MethodKind.DeclareMethod) AndAlso 1623If Me.MethodKind <> MethodKind.Ordinary AndAlso Me.MethodKind <> MethodKind.DeclareMethod Then 1808Case MethodKind.DeclareMethod 1812Case MethodKind.PropertyGet, MethodKind.PropertySet 1816Case MethodKind.EventAdd, MethodKind.EventRaise, MethodKind.EventRemove 1900Debug.Assert(MethodKind <> MethodKind.DeclareMethod) 1991Case MethodKind.Constructor, 1992MethodKind.SharedConstructor, 1993MethodKind.PropertyGet, 1994MethodKind.PropertySet, 1995MethodKind.EventAdd, 1996MethodKind.EventRemove, 1997MethodKind.EventRaise, 1998MethodKind.Conversion, 1999MethodKind.UserDefinedOperator 2286Case MethodKind.Constructor, 2287MethodKind.SharedConstructor, 2288MethodKind.EventRemove, 2289MethodKind.EventRaise 2294Case MethodKind.EventAdd 2300Case MethodKind.PropertyGet, MethodKind.PropertySet 2322If Me.MethodKind = MethodKind.UserDefinedOperator Then

Symbols\Source\SourceNamedTypeSymbol.vb (2)

2721If method.MethodKind = MethodKind.Constructor AndAlso method.ParameterCount = 0 Then 2730If method.MethodKind = MethodKind.Constructor AndAlso method.CanBeCalledWithNoParameters() Then

Symbols\Source\SourceNamedTypeSymbol_ComClass.vb (8)

382If DirectCast(member, MethodSymbol).MethodKind <> MethodKind.Ordinary Then 548Debug.Assert(method.MethodKind = MethodKind.Ordinary) 1234Public Overrides ReadOnly Property MethodKind As MethodKind 1237Case MethodKind.PropertyGet 1238Return MethodKind.PropertyGet 1239Case MethodKind.PropertySet 1240Return MethodKind.PropertySet 1242Return MethodKind.Ordinary

Symbols\Source\SourceNamedTypeSymbol_GroupClass.vb (2)

402ConflictsWithExistingMemberOrType(binder.GetAccessorName(propertyName, MethodKind.PropertyGet, False), membersBuilder, nestedTypes, conflictsWith) OrElse 403(disposeMethod.Length > 0 AndAlso ConflictsWithExistingMemberOrType(binder.GetAccessorName(propertyName, MethodKind.PropertySet, isWinMd), membersBuilder, nestedTypes, conflictsWith)) OrElse

Symbols\Source\SourceParameterSymbol.vb (8)

103If If(TryCast(Me.ContainingSymbol, MethodSymbol)?.MethodKind = MethodKind.DelegateInvoke, False) AndAlso 186If containingSymbol.Kind = SymbolKind.Method AndAlso DirectCast(containingSymbol, MethodSymbol).MethodKind = MethodKind.DeclareMethod Then 208Case MethodKind.Conversion, 209MethodKind.UserDefinedOperator, 210MethodKind.EventAdd, 211MethodKind.EventRemove 452If methodSymbol.MethodKind = MethodKind.DeclareMethod Then 496DirectCast(ContainingSymbol, MethodSymbol).MethodKind = MethodKind.DeclareMethod Then

Symbols\Source\SourcePropertyAccessorSymbol.vb (11)

Symbols\Source\SourcePropertySymbol.vb (2)

204Binder.GetAccessorName(prop.Name, MethodKind.PropertyGet, isWinMd:=False), 213Binder.GetAccessorName(prop.Name, MethodKind.PropertySet,

Symbols\Source\SynthesizedEntryPointSymbol.vb (2)

163Public Overrides ReadOnly Property MethodKind As MethodKind 165Return MethodKind.Ordinary

Symbols\Source\SynthesizedEventAccessorSymbol.vb (8)

54If Me.MethodKind = MethodKind.EventRemove AndAlso m_propertyOrEvent.IsWindowsRuntimeEvent Then 84useSiteInfo = If(Me.MethodKind = MethodKind.EventRemove, Binder.GetUseSiteInfoForSpecialType(type), Nothing) 104Return Not (Me.MethodKind = MethodKind.EventAdd AndAlso m_propertyOrEvent.IsWindowsRuntimeEvent) 110Return ConstructFieldLikeEventAccessorBody(Me.m_propertyOrEvent, Me.MethodKind = MethodKind.EventAdd, compilation, diagnostics) 541Public Overrides ReadOnly Property MethodKind As MethodKind 543Return MethodKind.EventAdd 556Public Overrides ReadOnly Property MethodKind As MethodKind 558Return MethodKind.EventRemove

Symbols\Source\SynthesizedInteractiveInitializerMethod.vb (2)

105Public Overrides ReadOnly Property MethodKind As MethodKind 107Return MethodKind.Ordinary

Symbols\Source\SynthesizedMyGroupCollectionPropertyAccessorSymbol.vb (4)

158Public Overrides ReadOnly Property MethodKind As MethodKind 160Return MethodKind.PropertyGet 203Public Overrides ReadOnly Property MethodKind As MethodKind 205Return MethodKind.PropertySet

Symbols\Source\SynthesizedWithEventsAccessorSymbol.vb (6)

45Return sourceProperty.GetAccessorImplementations(getter:=(MethodKind = MethodKind.PropertyGet)) 53Return ContainingProperty.GetAccessorOverride(getter:=(MethodKind = MethodKind.PropertyGet)) 130Public Overrides ReadOnly Property MethodKind As MethodKind 132Return MethodKind.PropertyGet 178Public Overrides ReadOnly Property MethodKind As MethodKind 180Return MethodKind.PropertySet

Symbols\SubstitutedMethodSymbol.vb (1)

283Public Overrides ReadOnly Property MethodKind As MethodKind

Symbols\SubstitutedNamedType.vb (6)

463Case MethodKind.PropertyGet, MethodKind.PropertySet 466Return If(memberMethod.MethodKind = MethodKind.PropertyGet, propertySymbol.GetMethod, propertySymbol.SetMethod) 468Case MethodKind.EventAdd 473Case MethodKind.EventRemove 478Case MethodKind.EventRaise

Symbols\Symbol.vb (12)

619Case MethodKind.Ordinary, MethodKind.DeclareMethod, MethodKind.ReducedExtension 621Case MethodKind.DelegateInvoke, MethodKind.UserDefinedOperator, MethodKind.Conversion 659Case MethodKind.Ordinary, MethodKind.DeclareMethod, MethodKind.ReducedExtension, MethodKind.DelegateInvoke, MethodKind.UserDefinedOperator, MethodKind.Conversion

Symbols\Symbol_Attributes.vb (12)

74Case MethodKind.Constructor, 75MethodKind.SharedConstructor 78Case MethodKind.Ordinary, 79MethodKind.DeclareMethod, 80MethodKind.UserDefinedOperator, 81MethodKind.Conversion, 82MethodKind.PropertyGet, 83MethodKind.PropertySet, 84MethodKind.EventAdd, 85MethodKind.EventRaise, 86MethodKind.EventRemove, 87MethodKind.DelegateInvoke

Symbols\SymbolExtensions.vb (6)

59Case MethodKind.Conversion, MethodKind.UserDefinedOperator, MethodKind.BuiltinOperator 263Return kind = MethodKind.Constructor OrElse kind = MethodKind.SharedConstructor 456While If(member?.Kind = SymbolKind.Method, False) AndAlso DirectCast(member, MethodSymbol).MethodKind = MethodKind.AnonymousFunction

Symbols\SynthesizedSymbols\SynthesizedConstructorBase.vb (3)

190Public NotOverridable Overrides ReadOnly Property MethodKind As MethodKind 192Return If(m_isShared, MethodKind.SharedConstructor, MethodKind.Constructor)

Symbols\SynthesizedSymbols\SynthesizedDelegateMethodSymbol.vb (2)

315Public Overrides ReadOnly Property MethodKind As MethodKind 419Return Me.MethodKind = MethodKind.Constructor

Symbols\SynthesizedSymbols\SynthesizedGlobalMethodBase.vb (2)

159Public Overrides ReadOnly Property MethodKind As MethodKind 161Return MethodKind.Ordinary

Symbols\SynthesizedSymbols\SynthesizedInterfaceImplementationStubSymbol.vb (2)

172Public Overrides ReadOnly Property MethodKind As MethodKind 174Return MethodKind.Ordinary

Symbols\SynthesizedSymbols\SynthesizedIntrinsicOperatorSymbol.vb (2)

158Public Overrides ReadOnly Property MethodKind As MethodKind 160Return MethodKind.BuiltinOperator

Symbols\SynthesizedSymbols\SynthesizedMethod.vb (2)

197Public Overrides ReadOnly Property MethodKind As MethodKind 199Return MethodKind.Ordinary

Symbols\SynthesizedSymbols\SynthesizedParameterSymbol.vb (2)

106Debug.Assert(propertySetter.MethodKind = MethodKind.PropertySet) 116If method.MethodKind = MethodKind.PropertySet AndAlso

Symbols\SynthesizedSymbols\SynthesizedRegularMethodBase.vb (2)

140Public NotOverridable Overrides ReadOnly Property MethodKind As MethodKind 142Return MethodKind.Ordinary

Symbols\WellKnownMembers.vb (4)

428Dim targetMethodKind As MethodKind = MethodKind.Ordinary 435targetMethodKind = MethodKind.Constructor 443targetMethodKind = MethodKind.PropertyGet

Symbols\Wrapped\WrappedMethodSymbol.vb (1)

168Public Overrides ReadOnly Property MethodKind As MethodKind

Microsoft.CodeAnalysis.VisualBasic.CodeStyle (2)

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

159methodSymbol?.MethodKind = MethodKind.Ordinary AndAlso 397If method.MethodKind = MethodKind.ReducedExtension AndAlso

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

src\Analyzers\VisualBasic\CodeFixes\GenerateConstructor\VisualBasicGenerateConstructorService.vb (1)

183Return If(methodSymbol IsNot Nothing AndAlso methodSymbol.MethodKind = MethodKind.Constructor, methodSymbol, Nothing)

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (1)

163methodKind:=MethodKind.Conversion)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (2)

153If method.MethodKind = MethodKind.UserDefinedOperator Then 157If method.MethodKind = MethodKind.Conversion Then

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

19If symbol.IsStatic AndAlso Not symbol.MethodKind = MethodKind.ReducedExtension Then

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

Attributes\AttributeTests_Tuples.vb (1)

254If DirectCast(s, MethodSymbol).MethodKind = MethodKind.EventRaise Then

Emit\EmitMetadata.vb (2)

787Assert.Equal(MethodKind.Constructor, ctor.MethodKind) 808Assert.Equal(MethodKind.SharedConstructor, cctor.MethodKind)

Microsoft.CodeAnalysis.VisualBasic.ExpressionCompiler (6)

Symbols\EEMethodSymbol.vb (2)

188Public Overrides ReadOnly Property MethodKind As MethodKind 190Return MethodKind.Ordinary

Symbols\PlaceholderMethodSymbol.vb (2)

105Public Overrides ReadOnly Property MethodKind As MethodKind 107Return MethodKind.Ordinary

Symbols\SynthesizedContextMethodSymbol.vb (2)

63Public Overrides ReadOnly Property MethodKind As MethodKind 65Return MethodKind.Ordinary

Microsoft.CodeAnalysis.VisualBasic.Features (14)

ChangeSignature\VisualBasicChangeSignatureService.vb (1)

360If methodSymbol IsNot Nothing AndAlso methodSymbol.MethodKind = MethodKind.ReducedExtension Then

CodeFixes\IncorrectExitContinue\IncorrectExitContinueCodeFixProvider.vb (2)

164If methodSymbol.MethodKind = MethodKind.PropertyGet Then 166ElseIf methodSymbol.MethodKind = MethodKind.PropertySet Then

EditAndContinue\VisualBasicEditAndContinueAnalyzer.vb (6)

635If method Is Nothing OrElse (method.MethodKind <> MethodKind.Constructor AndAlso method.MethodKind <> MethodKind.SharedConstructor) Then 1445Case MethodKind.StaticConstructor 1447Case MethodKind.LambdaMethod 2038If method.MethodKind = MethodKind.Conversion OrElse method.MethodKind = MethodKind.UserDefinedOperator Then

NavigationBar\VisualBasicNavigationBarItemService.vb (3)

277Return method.MethodKind = MethodKind.Ordinary OrElse 278method.MethodKind = MethodKind.UserDefinedOperator OrElse 279method.MethodKind = MethodKind.Conversion

src\Analyzers\VisualBasic\CodeFixes\GenerateConstructor\VisualBasicGenerateConstructorService.vb (1)

183Return If(methodSymbol IsNot Nothing AndAlso methodSymbol.MethodKind = MethodKind.Constructor, methodSymbol, Nothing)

src\Analyzers\VisualBasic\CodeFixes\GenerateParameterizedMember\VisualBasicGenerateConversionService.vb (1)

163methodKind:=MethodKind.Conversion)

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

Compilation\SemanticModelGetDeclaredSymbolAPITests.vb (2)

1152Assert.Equal(MethodKind.Conversion, sym1.MethodKind) 1153Assert.Equal(MethodKind.UserDefinedOperator, sym2.MethodKind)

DeclaringSyntaxNodeTests.vb (2)

134Assert.Equal(MethodKind.LambdaMethod, sym.MethodKind) 514If memb.Kind = SymbolKind.Method AndAlso (DirectCast(memb, MethodSymbol)).MethodKind = MethodKind.Constructor Then

ExtensionMethods\SemanticModelTests.vb (3)

61Assert.Equal(MethodKind.ReducedExtension, method.MethodKind) 65Assert.Equal(MethodKind.Ordinary, method.CallsiteReducedFromMethod.MethodKind) 70Assert.Equal(MethodKind.ReducedExtension, reducedMethod.MethodKind)

Semantics\AnonymousTypesTests.vb (3)

1501Assert.Equal(MethodKind.LambdaMethod, lambda2.MethodKind) 1546Assert.Equal(MethodKind.LambdaMethod, lambda2.MethodKind) 1591Assert.Equal(MethodKind.LambdaMethod, lambda2.MethodKind)

Semantics\BinaryOperators.vb (2)

1109If method.MethodKind = MethodKind.UserDefinedOperator AndAlso 1225Assert.Equal(MethodKind.BuiltinOperator, symbol1.MethodKind)

Semantics\GetExtendedSemanticInfoTests.vb (4)

4359Assert.Equal(MethodKind.Constructor, method.MethodKind) 4398Assert.Equal(MethodKind.Constructor, method.MethodKind) 4434Assert.Equal(MethodKind.Constructor, method.MethodKind) 4473Assert.Equal(MethodKind.Constructor, method.MethodKind)

Semantics\OptionalArgumentTests.vb (5)

2202Dim methods = [module].GlobalNamespace.GetMember(Of NamedTypeSymbol)("C").GetMembers().OfType(Of MethodSymbol)().Where(Function(m) m.MethodKind = MethodKind.Ordinary).ToArray() 2313Dim methods = [module].GlobalNamespace.GetMember(Of NamedTypeSymbol)("C").GetMembers().OfType(Of MethodSymbol)().Where(Function(m) m.MethodKind = MethodKind.Ordinary).ToArray() 2402Dim methods = [module].GlobalNamespace.GetMember(Of NamedTypeSymbol)("C").GetMembers().OfType(Of MethodSymbol)().Where(Function(m) m.MethodKind = MethodKind.Ordinary).ToArray() 2524Dim methods = [module].GlobalNamespace.GetMember(Of NamedTypeSymbol)("C").GetMembers().OfType(Of MethodSymbol)().Where(Function(m) m.MethodKind = MethodKind.Ordinary).ToArray() 2685Dim methods = [module].GlobalNamespace.GetMember(Of NamedTypeSymbol)("C").GetMembers().OfType(Of MethodSymbol)().Where(Function(m) m.MethodKind = MethodKind.Ordinary).ToArray()

Semantics\UnaryOperators.vb (1)

756Assert.Equal(MethodKind.BuiltinOperator, symbol1.MethodKind)

Semantics\UsingStatementTest.vb (1)

345If (DirectCast(type.Symbol, MethodSymbol).MethodKind = MethodKind.Constructor) Then

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

SymbolsTests\AnonymousDelegates\AnonymousDelegates_CreationAndEmit.vb (4)

306Assert.Equal(MethodKind.Constructor, x16.GetMethod(".ctor").MethodKind) 308Assert.Equal(MethodKind.DelegateInvoke, x16.GetMember(Of MethodSymbol)("Invoke").MethodKind) 310Assert.Equal(MethodKind.Ordinary, x16.GetMember(Of MethodSymbol)("BeginInvoke").MethodKind) 312Assert.Equal(MethodKind.Ordinary, x16.GetMember(Of MethodSymbol)("EndInvoke").MethodKind)

SymbolsTests\CheckedUserDefinedOperatorsTests.vb (18)

SymbolsTests\Metadata\MetadataMemberTests.vb (4)

168Assert.Equal(MethodKind.Constructor, ctor.MethodKind) 214Assert.Equal(MethodKind.Ordinary, member1.MethodKind) 732If m.MethodKind = MethodKind.Constructor Then 737Assert.NotEqual(MethodKind.Ordinary, m.MethodKind)

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

105Case MethodKind.EventAdd 108Case MethodKind.EventRemove

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

SymbolsTests\Metadata\PE\LoadingOperators.vb (122)

SymbolsTests\Source\DelegateTests.vb (1)

248Assert.Equal(MethodKind.DelegateInvoke, invoke.MethodKind)

SymbolsTests\Source\EventTests.vb (2)

1732Assert.Equal(MethodKind.EventAdd, DirectCast(mems(2), MethodSymbol).MethodKind) 1736Assert.Equal(MethodKind.EventRemove, DirectCast(mems(4), MethodSymbol).MethodKind)

SymbolsTests\Source\ImplementsTests.vb (1)

3813Single(Function(m) m.ExplicitInterfaceImplementations.Single().MethodKind = MethodKind.EventAdd)

SymbolsTests\Source\MethodTests.vb (9)

67Assert.Equal(MethodKind.Constructor, ctor.MethodKind) 86Assert.Equal(MethodKind.Ordinary, m1.MethodKind) 194Assert.Equal(MethodKind.Ordinary, m1.MethodKind) 243Assert.Equal(MethodKind.Constructor, m1.MethodKind) 262Assert.Equal(MethodKind.Constructor, m2.MethodKind) 316Assert.Equal(MethodKind.SharedConstructor, m1.MethodKind) 336Assert.Equal(MethodKind.SharedConstructor, m2.MethodKind) 389Assert.Equal(MethodKind.Constructor, m1.MethodKind) 414Assert.Equal(MethodKind.Constructor, m2.MethodKind)

SymbolsTests\Source\OperatorsTests.vb (60)

SymbolsTests\Source\PropertyTests.vb (20)

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

BasicTrackingDiagnosticAnalyzer.vb (3)

14Protected Overrides Function IsOnCodeBlockSupported(symbolKind As SymbolKind, methodKind As MethodKind, returnsVoid As Boolean) As Boolean 16methodKind <> MethodKind.Destructor AndAlso 17methodKind <> MethodKind.ExplicitInterfaceImplementation

MockSymbols.vb (2)

592Public Overrides ReadOnly Property MethodKind As MethodKind 594Return MethodKind.Ordinary

Microsoft.CodeAnalysis.VisualBasic.Workspaces (13)

CaseCorrection\VisualBasicCaseCorrectionService.Rewriter.vb (1)

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

Classification\SyntaxClassification\NameSyntaxClassifier.vb (3)

212Case MethodKind.Constructor 224Case MethodKind.BuiltinOperator, 225MethodKind.UserDefinedOperator

Classification\SyntaxClassification\OperatorOverloadSyntaxClassifier.vb (1)

42DirectCast(symbolInfo.Symbol, IMethodSymbol).MethodKind = MethodKind.UserDefinedOperator Then

CodeCleanup\Providers\AddMissingTokensCodeCleanupProvider.vb (1)

124Function(s) If(TryCast(s, IMethodSymbol)?.MethodKind = MethodKind.Ordinary, False))

Recommendations\VisualBasicRecommendationServiceRunner.vb (2)

343symbols = symbols.WhereAsArray(Function(s) s.Kind <> SymbolKind.Method OrElse DirectCast(s, IMethodSymbol).MethodKind <> MethodKind.UserDefinedOperator) 382If method IsNot Nothing AndAlso method.MethodKind = MethodKind.Constructor Then

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

159methodSymbol?.MethodKind = MethodKind.Ordinary AndAlso 397If method.MethodKind = MethodKind.ReducedExtension AndAlso

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\VisualBasic\CodeGeneration\VisualBasicCodeGenerationService.vb (2)

153If method.MethodKind = MethodKind.UserDefinedOperator Then 157If method.MethodKind = MethodKind.Conversion Then

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

19If symbol.IsStatic AndAlso Not symbol.MethodKind = MethodKind.ReducedExtension Then

Microsoft.CodeAnalysis.Workspaces (163)

Editing\SyntaxGenerator.cs (12)

280if (method.MethodKind is not (MethodKind.UserDefinedOperator or MethodKind.Conversion)) 736case MethodKind.Constructor: 737case MethodKind.SharedConstructor: 740case MethodKind.Destructor: 743case MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation: 746case MethodKind.UserDefinedOperator or MethodKind.Conversion: 833case MethodKind.Constructor: 834case MethodKind.SharedConstructor: 836case MethodKind.Ordinary:

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

17=> symbol.MethodKind == MethodKind.Constructor;

FindSymbols\FindReferences\Finders\ConstructorSymbolReferenceFinder.cs (4)

26=> symbol.MethodKind is MethodKind.Constructor or MethodKind.StaticConstructor; 30if (symbol.MethodKind is MethodKind.Constructor) 86if (symbol.MethodKind == MethodKind.Constructor)

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

16=> symbol.MethodKind == MethodKind.Destructor;

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

20=> symbol is { MethodKind: MethodKind.Conversion, Name: WellKnownMemberNames.ExplicitConversionName or WellKnownMemberNames.ImplicitConversionName } &&

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

16=> symbol.MethodKind == MethodKind.ExplicitInterfaceImplementation;

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

68ContainingSymbol: IMethodSymbol { MethodKind: MethodKind.LocalFunction },

FindSymbols\FindReferences\Finders\OperatorSymbolReferenceFinder.cs (2)

19=> symbol.MethodKind is MethodKind.UserDefinedOperator or MethodKind.BuiltinOperator;

FindSymbols\FindReferences\Finders\OrdinaryMethodReferenceFinder.cs (5)

16=> symbol.MethodKind is MethodKind.Ordinary or 17MethodKind.DelegateInvoke or 18MethodKind.DeclareMethod or 19MethodKind.ReducedExtension or 20MethodKind.LocalFunction;

FindSymbols\FindReferences\Finders\ParameterSymbolReferenceFinder.cs (2)

175if (declaredSymbol is IMethodSymbol { MethodKind: not MethodKind.AnonymousFunction }) 213if (containingMethod.MethodKind == MethodKind.DelegateInvoke)

FindSymbols\ReferenceLocationExtensions.cs (1)

94if (method.MethodKind != MethodKind.AnonymousFunction)

ReassignedVariable\AbstractReassignedVariableService.cs (2)

184if (methodOrProperty is IMethodSymbol { MethodKind: MethodKind.PropertyGet or MethodKind.PropertySet } method)

Recommendations\AbstractRecommendationService.cs (5)

84case MethodKind.EventAdd: 85case MethodKind.EventRemove: 86case MethodKind.EventRaise: 87case MethodKind.PropertyGet: 88case MethodKind.PropertySet:

Recommendations\AbstractRecommendationServiceRunner.cs (1)

68if (parameter.ContainingSymbol is not IMethodSymbol { MethodKind: MethodKind.AnonymousFunction } owningMethod)

Rename\RenameUtilities.cs (3)

342if (symbol is IMethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.StaticConstructor or MethodKind.Destructor })

Rename\SymbolicRenameLocations.ReferenceProcessing.cs (3)

210MethodKind: MethodKind.Constructor or MethodKind.StaticConstructor or MethodKind.Destructor,

Shared\Extensions\ISymbolExtensions.cs (2)

475if (methodSymbol.MethodKind is MethodKind.Constructor or MethodKind.StaticConstructor)

Shared\Extensions\ISymbolExtensions_2.cs (3)

17if (method.MethodKind is MethodKind.EventAdd or 18MethodKind.EventRemove or 19MethodKind.PropertySet)

Shared\Extensions\SemanticModelExtensions.cs (1)

53methodSymbol.MethodKind == MethodKind.BuiltinOperator &&

Shared\Extensions\SyntaxGeneratorExtensions.cs (1)

242if (overriddenMethod.IsAbstract || overriddenMethod.MethodKind == MethodKind.UserDefinedOperator)

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

48if (symbol.MethodKind == MethodKind.BuiltinOperator)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\INamedTypeSymbolExtensions.cs (6)

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

30MethodKind: MethodKind.Constructor, 62MethodKind: MethodKind.Constructor,

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

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

153if (symbol is IMethodSymbol { MethodKind: MethodKind.BuiltinOperator })

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Extensions\MethodKindExtensions.cs (3)

9public static bool IsPropertyAccessor(this MethodKind kind) 10=> kind is MethodKind.PropertyGet or MethodKind.PropertySet;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\FlowAnalysis\SymbolUsageAnalysis\SymbolUsageAnalysis.Walker.cs (3)

325case MethodKind.AnonymousFunction: 326case MethodKind.DelegateInvoke: 338case MethodKind.LocalFunction:

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

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

46return method.MethodKind is MethodKind.Ordinary or 47MethodKind.LocalFunction;

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

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Services\SemanticFacts\ISemanticFactsExtensions.cs (1)

113methodSymbol.MethodKind == MethodKind.UserDefinedOperator;

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.cs (2)

74/// cref="IRangeVariableSymbol"/> and <see cref="MethodKind.LocalFunction"/> <see cref="IMethodSymbol"/>s can also 321IMethodSymbol { MethodKind: MethodKind.LocalFunction } => true,

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.MethodSymbolKey.cs (1)

143if (symbol.MethodKind == MethodKind.Conversion)

src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\SymbolKey\SymbolKey.SymbolKeyWriter.cs (4)

373case MethodKind.AnonymousFunction: 378case MethodKind.BuiltinOperator: 383case MethodKind.ReducedExtension: 388case MethodKind.LocalFunction:

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

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

78if ((method1.MethodKind == MethodKind.AnonymousFunction) != 79(method2.MethodKind == MethodKind.AnonymousFunction)) 84if (method1.MethodKind != MethodKind.AnonymousFunction)

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

199if (x is { MethodKind: MethodKind.DelegateInvoke, ContainingType.IsAnonymousType: true }) 204if (x.MethodKind == MethodKind.FunctionPointerSignature)

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

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

112if (x.MethodKind == MethodKind.AnonymousFunction)

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\CodeGenerationSymbolFactory.cs (4)

166MethodKind methodKind = MethodKind.Ordinary, 187MethodKind methodKind = MethodKind.Ordinary,

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

77public virtual MethodKind MethodKind => MethodKind.Ordinary;

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

32public override MethodKind MethodKind => MethodKind.Constructor;

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

39public override MethodKind MethodKind => MethodKind.Conversion;

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

23public override MethodKind MethodKind => MethodKind.Destructor;

src\Workspaces\SharedUtilitiesAndExtensions\Workspace\Core\CodeGeneration\Symbols\CodeGenerationMethodSymbol.cs (5)

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

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

37public override MethodKind MethodKind => MethodKind.UserDefinedOperator;

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (1)

Options\NamingStyleTestUtilities.cs (1)

77MethodKind methodKind => new SymbolSpecification.SymbolKindOrTypeKind(methodKind),

Microsoft.CodeAnalysis.Workspaces.UnitTests (28)

EditorConfigParsing\NamingStyleParserTests.cs (3)

162symbolKind => Assert.Equal(new SymbolKindOrTypeKind(MethodKind.Ordinary), symbolKind), 163symbolKind => Assert.Equal(new SymbolKindOrTypeKind(MethodKind.LocalFunction), symbolKind), 240symbolKind => Assert.Equal(new SymbolKindOrTypeKind(MethodKind.LocalFunction), symbolKind));

Options\EditorConfigNamingStyleParserTests.cs (12)

Options\NamingStylePreferencesTests.cs (5)

197[InlineData(typeof(MethodKind), nameof(MethodKind.AnonymousFunction), nameof(MethodKind.LambdaMethod), nameof(MethodKind.SharedConstructor), nameof(MethodKind.StaticConstructor))]

UtilityTest\DocumentationCommentIdTests.cs (8)

Microsoft.Gen.Logging (1)

Parsing\Parser.Records.cs (1)

73if (m is not IMethodSymbol { MethodKind: MethodKind.Constructor } ctorMethod)

Microsoft.Interop.ComInterfaceGenerator (2)

ComMethodInfo.cs (2)

58case IMethodSymbol { MethodKind: MethodKind.Ordinary }: 89Debug.Assert(method is { IsStatic: false, MethodKind: MethodKind.Ordinary });

Microsoft.VisualStudio.LanguageServices (23)

Implementation\VsRefactorNotifyService.cs (2)

161if (symbol is IMethodSymbol { MethodKind: MethodKind.Constructor or MethodKind.Destructor })

Library\ObjectBrowser\AbstractListItemFactory.cs (2)

347if (methodSymbol.MethodKind is MethodKind.Destructor or MethodKind.Constructor ||

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

40Kind = methodSymbol.MethodKind is MethodKind.Conversion or 41MethodKind.UserDefinedOperator

Progression\GraphBuilder.cs (14)

386if (methodSymbol.MethodKind == MethodKind.Constructor) 390else if (methodSymbol.MethodKind == MethodKind.StaticConstructor) 394else if (methodSymbol.MethodKind == MethodKind.Destructor) 522case MethodKind.AnonymousFunction: 526case MethodKind.BuiltinOperator: 527case MethodKind.UserDefinedOperator: 531case MethodKind.Constructor: 532case MethodKind.StaticConstructor: 536case MethodKind.Conversion: 541case MethodKind.Destructor: 545case MethodKind.PropertyGet: 549case MethodKind.PropertySet: 624var isOperator = method.MethodKind is MethodKind.UserDefinedOperator or MethodKind.Conversion;

Progression\GraphNodeIdCreation.cs (1)

322if (member is IMethodSymbol methodSymbol && methodSymbol.MethodKind == MethodKind.Conversion)

Progression\GraphQueries\CallsGraphQuery.cs (1)

58(newSymbol.CanBeReferencedByName || ((IMethodSymbol)newSymbol).MethodKind == MethodKind.Constructor))

Progression\RoslynGraphProperties.cs (1)

83dataType: typeof(MethodKind),

Microsoft.VisualStudio.LanguageServices.CSharp (37)

CodeModel\CSharpCodeModelService.cs (27)

LanguageService\CSharpHelpContextService.cs (1)

195if (symbol is IMethodSymbol method && method.MethodKind == MethodKind.BuiltinOperator)

ObjectBrowser\DescriptionBuilder.cs (7)

190if (methodSymbol.MethodKind is not MethodKind.Constructor and 191not MethodKind.Destructor and 192not MethodKind.StaticConstructor and 193not MethodKind.Conversion) 199if (methodSymbol.MethodKind == MethodKind.Conversion) 247methodSymbol.MethodKind == MethodKind.Destructor) 262methodSymbol.MethodKind != MethodKind.StaticConstructor)

Progression\CSharpProgressionLanguageService.cs (2)

127=> f.MethodKind is MethodKind.Ordinary or MethodKind.ExplicitInterfaceImplementation;

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

GlyphExtensionsTests.cs (7)

47methodKind: MethodKind.ReducedExtension); 154methodKind: MethodKind.UserDefinedOperator); 163methodKind: MethodKind.Conversion); 180MethodKind methodKind = MethodKind.Ordinary, 197MethodKind methodKind = MethodKind.Ordinary,

Microsoft.VisualStudio.LanguageServices.UnitTests (2)

CommonControls\NewTypeDestinationSelectionViewModelTests.vb (1)

238Dim extractableMembers = DirectCast(symbol, INamedTypeSymbol).GetMembers().Where(Function(s) Not (TypeOf s Is IMethodSymbol) OrElse DirectCast(s, IMethodSymbol).MethodKind <> MethodKind.Constructor)

ExtractInterface\ExtractInterfaceViewModelTests.vb (1)

301Dim extractableMembers = DirectCast(symbol, INamedTypeSymbol).GetMembers().Where(Function(s) Not (TypeOf s Is IMethodSymbol) OrElse DirectCast(s, IMethodSymbol).MethodKind <> MethodKind.Constructor)

Microsoft.VisualStudio.LanguageServices.VisualBasic (33)

CodeModel\VisualBasicCodeModelService.vb (28)

CodeModel\VisualBasicCodeModelService_Prototype.vb (1)

96If methodSymbol.MethodKind = MethodKind.Ordinary AndAlso

ObjectBrowser\DescriptionBuilder.vb (4)

125Case MethodKind.Conversion, MethodKind.UserDefinedOperator 127Case MethodKind.DeclareMethod 365(methodSymbol Is Nothing OrElse Not methodSymbol.MethodKind = MethodKind.DeclareMethod) AndAlso

Roslyn.Diagnostics.Analyzers (30)

DoNotMixAttributesFromDifferentVersionsOfMEF.cs (1)

103if (member is IMethodSymbol methodSymbol && methodSymbol.MethodKind == MethodKind.Constructor)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (6)

Roslyn.Diagnostics.CSharp.Analyzers (1)

CSharpDoNotCapturePrimaryContructorParameters.cs (1)

41if (operation.Parameter.ContainingSymbol == context.ContainingSymbol || operation.Parameter.ContainingSymbol is not IMethodSymbol { MethodKind: MethodKind.Constructor })

Test.Utilities (29)

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (6)

Text.Analyzers (33)

IdentifiersShouldBeSpelledCorrectly.cs (4)

323case MethodKind.PropertyGet: 324case MethodKind.PropertySet: 327case MethodKind.Constructor: 328case MethodKind.StaticConstructor:

src\RoslynAnalyzers\Utilities\Compiler\Extensions\IMethodSymbolExtensions.cs (19)

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

84return symbol.GetMembers(op).OfType<IMethodSymbol>().Any(m => m.MethodKind == MethodKind.UserDefinedOperator);

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

src\RoslynAnalyzers\Utilities\Compiler\Extensions\MethodKindEx.cs (6)