public virtual SymbolFilterReason GetReason(IMethodSymbol symbol)
{
bool canBeImplicitlyDeclared = false;
if (!Includes(SymbolGroupFilter.Method))
{
return(SymbolFilterReason.SymbolGroup);
}
switch (symbol.MethodKind)
{
case MethodKind.Constructor:
{
TypeKind typeKind = symbol.ContainingType.TypeKind;
Debug.Assert(typeKind.Is(TypeKind.Class, TypeKind.Struct, TypeKind.Enum), symbol.ToDisplayString(SymbolDisplayFormats.Test));
if (typeKind == TypeKind.Class &&
!symbol.Parameters.Any())
{
canBeImplicitlyDeclared = true;
}
break;
}
case MethodKind.Conversion:
case MethodKind.UserDefinedOperator:
case MethodKind.Ordinary:
case MethodKind.StaticConstructor:
case MethodKind.Destructor:
case MethodKind.ExplicitInterfaceImplementation:
{
break;
}
default:
{
return(SymbolFilterReason.Other);
}
}
if (!canBeImplicitlyDeclared && symbol.IsImplicitlyDeclared)
{
return(SymbolFilterReason.ImplicitlyDeclared);
}
if (!symbol.IsVisible(Visibility))
{
return(SymbolFilterReason.Visibility);
}
return(GetRulesReason(symbol));
}
public IEnumerable <IEventSymbol> GetEvents(bool includeInherited = false)
{
if (!TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in (GetMembers(includeInherited)))
{
if (member.Kind == SymbolKind.Event)
{
yield return((IEventSymbol)member);
}
}
}
}
public IEnumerable <INamedTypeSymbol> GetAllDerivedTypes()
{
if (TypeKind.Is(TypeKind.Class, TypeKind.Interface) &&
!IsStatic)
{
foreach (INamedTypeSymbol typeSymbol in DocumentationModel.Types)
{
if (typeSymbol.InheritsFrom(Symbol, includeInterfaces: true))
{
yield return(typeSymbol);
}
}
}
}
public IEnumerable <INamedTypeSymbol> GetDelegates(bool includeInherited = false)
{
if (!TypeKind.Is(TypeKind.Interface, TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in (GetMembers(includeInherited)))
{
if (member.Kind == SymbolKind.NamedType)
{
var namedType = (INamedTypeSymbol)member;
if (namedType.TypeKind == TypeKind.Delegate)
{
yield return(namedType);
}
}
}
}
}
public IEnumerable <IMethodSymbol> GetMethods(bool includeInherited = false)
{
if (!TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in (GetMembers(includeInherited)))
{
if (member.Kind == SymbolKind.Method)
{
var methodSymbol = (IMethodSymbol)member;
if (methodSymbol.MethodKind == MethodKind.Ordinary)
{
yield return(methodSymbol);
}
}
}
}
}
public IEnumerable <IPropertySymbol> GetProperties(bool includeInherited = false, bool includeIndexers = false)
{
if (!TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in (GetMembers(includeInherited)))
{
if (member.Kind == SymbolKind.Property)
{
var propertySymbol = (IPropertySymbol)member;
if (includeIndexers || !propertySymbol.IsIndexer)
{
yield return(propertySymbol);
}
}
}
}
}
public IEnumerable <IMethodSymbol> GetOperators(
bool includeInherited = false,
bool includeConversion = true,
bool includeUserDefinedOperator = true)
{
if (!TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in (GetMembers(includeInherited)))
{
if (member.Kind == SymbolKind.Method)
{
var methodSymbol = (IMethodSymbol)member;
switch (methodSymbol.MethodKind)
{
case MethodKind.UserDefinedOperator:
{
if (includeUserDefinedOperator)
{
yield return(methodSymbol);
}
break;
}
case MethodKind.Conversion:
{
if (includeConversion)
{
yield return(methodSymbol);
}
break;
}
}
}
}
}
}
public IEnumerable <IMethodSymbol> GetConstructors()
{
if (!TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
foreach (ISymbol member in Members)
{
if (member.Kind == SymbolKind.Method)
{
var methodSymbol = (IMethodSymbol)member;
if (methodSymbol.MethodKind == MethodKind.Constructor)
{
if (methodSymbol.ContainingType.TypeKind != TypeKind.Struct ||
methodSymbol.Parameters.Any())
{
yield return(methodSymbol);
}
}
}
}
}
}
public IEnumerable <INamedTypeSymbol> GetDerivedTypes()
{
if (TypeKind.Is(TypeKind.Class, TypeKind.Interface) &&
!IsStatic)
{
foreach (INamedTypeSymbol typeSymbol in DocumentationModel.Types)
{
if (typeSymbol.BaseType?.OriginalDefinition.Equals(Symbol) == true)
{
yield return(typeSymbol);
}
foreach (INamedTypeSymbol interfaceSymbol in typeSymbol.Interfaces)
{
if (interfaceSymbol.OriginalDefinition.Equals(Symbol))
{
yield return(typeSymbol);
}
}
}
}
}
internal IEnumerable <ISymbol> GetMembers(TypeDocumentationParts ignoredParts = TypeDocumentationParts.None)
{
if (!TypeKind.Is(TypeKind.Enum, TypeKind.Delegate))
{
if (IsEnabled(TypeDocumentationParts.Constructors))
{
foreach (IMethodSymbol result in GetConstructors())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Fields))
{
foreach (IFieldSymbol result in GetFields())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Indexers))
{
foreach (IPropertySymbol result in GetIndexers())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Properties))
{
foreach (IPropertySymbol result in GetProperties())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Methods))
{
foreach (IMethodSymbol result in GetMethods())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Operators))
{
foreach (IMethodSymbol result in GetOperators())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.Events))
{
foreach (IEventSymbol result in GetEvents())
{
yield return(result);
}
}
if (IsEnabled(TypeDocumentationParts.ExplicitInterfaceImplementations))
{
foreach (ISymbol result in GetExplicitInterfaceImplementations())
{
yield return(result);
}
}
bool IsEnabled(TypeDocumentationParts part)
{
return((ignoredParts & part) == 0);
}
}
}
public IEnumerable <ISymbol> GetExplicitInterfaceImplementations()
{
if (TypeKind.Is(TypeKind.Delegate, TypeKind.Enum))
{
yield break;
}
foreach (ISymbol member in Symbol.GetMembers())
{
switch (member.Kind)
{
case SymbolKind.Event:
{
var eventSymbol = (IEventSymbol)member;
if (!eventSymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty)
{
yield return(eventSymbol);
}
break;
}
case SymbolKind.Method:
{
var methodSymbol = (IMethodSymbol)member;
if (methodSymbol.MethodKind != MethodKind.ExplicitInterfaceImplementation)
{
break;
}
ImmutableArray <IMethodSymbol> explicitInterfaceImplementations = methodSymbol.ExplicitInterfaceImplementations;
if (explicitInterfaceImplementations.IsDefaultOrEmpty)
{
break;
}
if (methodSymbol.MetadataName.EndsWith(".get_Item", StringComparison.Ordinal))
{
if (explicitInterfaceImplementations[0].MethodKind == MethodKind.PropertyGet)
{
break;
}
}
else if (methodSymbol.MetadataName.EndsWith(".set_Item", StringComparison.Ordinal))
{
if (explicitInterfaceImplementations[0].MethodKind == MethodKind.PropertySet)
{
break;
}
}
yield return(methodSymbol);
break;
}
case SymbolKind.Property:
{
var propertySymbol = (IPropertySymbol)member;
if (!propertySymbol.ExplicitInterfaceImplementations.IsDefaultOrEmpty)
{
yield return(propertySymbol);
}
break;
}
}
}
}