Esempio n. 1
0
 static IEnumerable <ISymbol> GetImplements(ISymbol symbol, IApiFilter apiFilter)
 => symbol.ContainingType.AllInterfaces
 .Where(type => apiFilter.CanVisitApi(type))
 .SelectMany(type => type.GetMembers())
 .Where(
     x => apiFilter.CanVisitApi(x) &&
     symbol.Equals(
         symbol.ContainingType.FindImplementationForInterfaceMember(x)
         )
     );
Esempio n. 2
0
 static void AddInheritedMembers(
     ITypeSymbol symbol,
     INamespaceOrTypeSymbol type,
     Dictionary <string, string?> dict,
     IReadOnlyList <string> typeParameterNames,
     IApiFilter apiFilter
     )
 {
     foreach (var m in type.GetMembers()
              .Where(m => !(m is INamedTypeSymbol))
              .Where(
                  m => apiFilter.CanVisitApi(
                      m,
                      symbol.Equals(type) ||
                      !symbol.IsSealed ||
                      symbol.TypeKind != TypeKind.Struct
                      )
                  )
              .Where(x => x.IsInheritable()))
     {
         var id = symbol.ToString()?.Trim();
         if (id != null)
         {
             dict.TryAdd(id, type.Equals(symbol) ? null : m.ToDisplayString());
         }
     }
 }
Esempio n. 3
0
        static void GenerateInheritance(
            INamedTypeSymbol symbol,
            MetadataItem item,
            IApiFilter apiFilter
            )
        {
            var dict = new Dictionary <string, string?>();

            switch (symbol.TypeKind)
            {
            case TypeKind.Class:
            case TypeKind.Struct:
            {
                var type        = symbol;
                var inheritance = new List <string>();

                var typeParameterNames = symbol.IsGenericType
                        ? symbol.Accept(TypeGenericParameterNameVisitor.Instance)
                        : EmptyListOfString;

                while (type != null)
                {
                    inheritance.AddWhen(type.Kind == SymbolKind.ErrorType, "System.Object");
                    inheritance.AddWhen(!type.Equals(symbol), type.ToDisplayString());

                    AddInheritedMembers(symbol, type, dict, typeParameterNames, apiFilter);
                    type = type.BaseType;
                }

                if (symbol.TypeKind == TypeKind.Class)
                {
                    inheritance.Reverse();
                    item.Inheritance = inheritance;
                }

                item.Implements = symbol.AllInterfaces
                                  .Where(t => apiFilter.CanVisitApi(t))
                                  .Select(x => x.ToDisplayString())
                                  .ToList();

                break;
            }

            case TypeKind.Interface:
            {
                var typeParameterNames = symbol.IsGenericType
                        ? symbol.Accept(TypeGenericParameterNameVisitor.Instance)
                        : EmptyListOfString;
                AddInheritedMembers(symbol, symbol, dict, typeParameterNames, apiFilter);

                foreach (var t in symbol.AllInterfaces)
                {
                    AddInheritedMembers(symbol, t, dict, typeParameterNames, apiFilter);
                }

                break;
            }
            }

            item.InheritedMembers = dict.Values.Where(r => r != null).ToList() !;
        }