public static AttributeFilterData GetAttributeFilterData(AttributeData attribute)
{
return(new AttributeFilterData
{
Id = VisitorHelper.GetId(attribute.AttributeClass),
ConstructorArguments = attribute.ConstructorArguments.Select(GetLiteralString),
ConstructorNamedArguments = attribute.NamedArguments.ToDictionary(pair => pair.Key, pair => GetLiteralString(pair.Value))
});
}
public override MetadataItem VisitMethod(IMethodSymbol symbol)
{
MetadataItem result = GetYamlItem(symbol);
if (result == null)
{
return(null);
}
if (result.Syntax == null)
{
result.Syntax = new SyntaxDetail {
Content = new SortedList <SyntaxLanguage, string>()
};
}
if (symbol.TypeParameters.Length > 0)
{
if (result.Syntax.TypeParameters == null)
{
result.Syntax.TypeParameters = new List <ApiParameter>();
}
foreach (var p in symbol.TypeParameters)
{
var param = VisitorHelper.GetTypeParameterDescription(p, result, GetTripleSlashCommentParserContext(result, _preserveRawInlineComments));
result.Syntax.TypeParameters.Add(param);
}
}
var typeGenericParameters = symbol.ContainingType.IsGenericType ? symbol.ContainingType.Accept(TypeGenericParameterNameVisitor.Instance) : EmptyListOfString;
var methodGenericParameters = symbol.IsGenericMethod ? (from p in symbol.TypeParameters select p.Name).ToList() : EmptyListOfString;
AddMethodSyntax(symbol, result, typeGenericParameters, methodGenericParameters);
if (result.Syntax.Content == null)
{
result.Syntax.Content = new SortedList <SyntaxLanguage, string>();
}
_generator.GenerateSyntax(result.Type, symbol, result.Syntax, this);
_generator.GenerateMethod(symbol, result, this);
if (symbol.IsOverride && symbol.OverriddenMethod != null)
{
result.Overridden = AddSpecReference(symbol.OverriddenMethod, typeGenericParameters, methodGenericParameters);
}
AddMemberImplements(symbol, result, typeGenericParameters, methodGenericParameters);
result.Attributes = GetAttributeInfo(symbol.GetAttributes());
result.IsExplicitInterfaceImplementation = !symbol.ExplicitInterfaceImplementations.IsEmpty;
result.IsExtensionMethod = symbol.IsExtensionMethod;
return(result);
}
public static SymbolFilterData GetSymbolFilterData(ISymbol symbol)
{
return(new SymbolFilterData
{
Id = VisitorHelper.GetId(symbol),
Kind = GetExtendedSymbolKindFromSymbol(symbol),
Attributes = symbol.GetAttributes().Select(GetAttributeFilterData)
});
}
public override MetadataItem VisitProperty(IPropertySymbol symbol)
{
MetadataItem result = GetYamlItem(symbol);
if (result == null)
{
return(null);
}
if (result.Syntax == null)
{
result.Syntax = new SyntaxDetail {
Content = new SortedList <SyntaxLanguage, string>()
};
}
if (result.Syntax.Parameters == null)
{
result.Syntax.Parameters = new List <ApiParameter>();
}
if (result.Syntax.Content == null)
{
result.Syntax.Content = new SortedList <SyntaxLanguage, string>();
}
_generator.GenerateSyntax(result.Type, symbol, result.Syntax, this);
var typeGenericParameters = symbol.ContainingType.IsGenericType ? symbol.ContainingType.Accept(TypeGenericParameterNameVisitor.Instance) : EmptyListOfString;
if (symbol.Parameters.Length > 0)
{
foreach (var p in symbol.Parameters)
{
var id = AddSpecReference(p.Type, typeGenericParameters);
var param = VisitorHelper.GetParameterDescription(p, result, id, false, GetTripleSlashCommentParserContext(result, _preserveRawInlineComments));
Debug.Assert(param.Type != null);
result.Syntax.Parameters.Add(param);
}
}
{
var id = AddSpecReference(symbol.Type, typeGenericParameters);
result.Syntax.Return = VisitorHelper.GetParameterDescription(symbol, result, id, true, GetTripleSlashCommentParserContext(result, _preserveRawInlineComments));
Debug.Assert(result.Syntax.Return.Type != null);
}
if (symbol.IsOverride && symbol.OverriddenProperty != null)
{
result.Overridden = AddSpecReference(symbol.OverriddenProperty, typeGenericParameters);
}
_generator.GenerateProperty(symbol, result, this);
AddMemberImplements(symbol, result, typeGenericParameters);
result.Attributes = GetAttributeInfo(symbol.GetAttributes());
result.IsExplicitInterfaceImplementation = !symbol.ExplicitInterfaceImplementations.IsEmpty;
return(result);
}
public override MetadataItem DefaultVisit(ISymbol symbol)
{
if (!FilterVisitor.CanVisitApi(symbol))
{
return(null);
}
var item = new MetadataItem
{
Name = VisitorHelper.GetId(symbol),
CommentId = VisitorHelper.GetCommentId(symbol),
RawComment = symbol.GetDocumentationCommentXml(),
Language = Language,
};
item.DisplayNames = new SortedList <SyntaxLanguage, string>();
item.DisplayNamesWithType = new SortedList <SyntaxLanguage, string>();
item.DisplayQualifiedNames = new SortedList <SyntaxLanguage, string>();
item.Source = VisitorHelper.GetSourceDetail(symbol);
var assemblyName = symbol.ContainingAssembly?.Name;
item.AssemblyNameList = string.IsNullOrEmpty(assemblyName) ? null : new List <string> {
assemblyName
};
if (!(symbol is INamespaceSymbol))
{
var namespaceName = VisitorHelper.GetId(symbol.ContainingNamespace);
item.NamespaceName = string.IsNullOrEmpty(namespaceName) ? null : namespaceName;
}
VisitorHelper.FeedComments(item, GetTripleSlashCommentParserContext(item, _preserveRawInlineComments));
if (item.Exceptions != null)
{
foreach (var exceptions in item.Exceptions)
{
AddReference(exceptions.Type, exceptions.CommentId);
}
}
if (item.Sees != null)
{
foreach (var i in item.Sees.Where(l => l.LinkType == LinkType.CRef))
{
AddReference(i.LinkId, i.CommentId);
}
}
if (item.SeeAlsos != null)
{
foreach (var i in item.SeeAlsos.Where(l => l.LinkType == LinkType.CRef))
{
AddReference(i.LinkId, i.CommentId);
}
}
_generator.DefaultVisit(symbol, item, this);
return(item);
}
/// <summary>
/// spec extension method's receiver type.
/// for below overload: M(this A), M(this A, A), AddReference applies to the first method and AddSpecReference applies to the second method might get same id without prepending receiver type.
/// </summary>
/// <param name="symbol">symbol</param>
/// <param name="id">id</param>
/// <returns>id prefixed with receiver type</returns>
private static string SpecExtensionMethodReceiverType(IMethodSymbol symbol, string id)
{
if (symbol.ReducedFrom == null || symbol.ReceiverType == null)
{
return(id);
}
return(VisitorHelper.GetId(symbol.ReceiverType) + "." + id);
}
public bool IsMatch(ISymbol symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
return((_uidRegex == null || _uidRegex.IsMatch(VisitorHelper.GetId(symbol))) &&
(Kind == null || Kind.Value.Contains(symbol)) &&
(Attribute == null || Attribute.ContainedIn(symbol)));
}
public override void VisitDynamicType(IDynamicTypeSymbol symbol)
{
var id = VisitorHelper.GetId(symbol.OriginalDefinition);
ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem
{
DisplayName = NameVisitorCreator.GetCSharp(NameOptions.None).GetName(symbol),
DisplayNamesWithType = NameVisitorCreator.GetCSharp(NameOptions.WithType).GetName(symbol),
DisplayQualifiedNames = NameVisitorCreator.GetCSharp(NameOptions.Qualified).GetName(symbol),
Name = id,
});
}
public override void VisitField(IFieldSymbol symbol)
{
var id = VisitorHelper.GetId(symbol.OriginalDefinition);
ReferenceItem.Parts[SyntaxLanguage.VB].Add(new LinkItem
{
DisplayName = NameVisitorCreator.GetVB(NameOptions.WithGenericParameter).GetName(symbol),
DisplayQualifiedNames = NameVisitorCreator.GetVB(NameOptions.Qualified | NameOptions.WithGenericParameter).GetName(symbol),
Name = id,
IsExternalPath = symbol.IsExtern || symbol.DeclaringSyntaxReferences.Length == 0,
});
}
public string AddSpecReference(
ISymbol symbol,
IReadOnlyList <string> typeGenericParameters = null,
IReadOnlyList <string> methodGenericParameters = null)
{
try
{
return(_generator.AddSpecReference(symbol, typeGenericParameters, methodGenericParameters, _references, this));
}
catch (Exception ex)
{
throw new DocfxException($"Unable to generate spec reference for {VisitorHelper.GetCommentId(symbol)}", ex);
}
}
internal string AddSpecReference(
ISymbol symbol,
IReadOnlyList <string> typeGenericParameters,
IReadOnlyList <string> methodGenericParameters,
Dictionary <string, ReferenceItem> references,
SymbolVisitorAdapter adapter)
{
var rawId = VisitorHelper.GetId(symbol);
var id = SpecIdHelper.GetSpecId(symbol, typeGenericParameters, methodGenericParameters);
if (string.IsNullOrEmpty(id))
{
throw new InvalidDataException($"Fail to parse id for symbol {symbol.MetadataName} in namespace {symbol.ContainingSymbol?.MetadataName}.");
}
ReferenceItem reference = new ReferenceItem()
{
Parts = new SortedList <SyntaxLanguage, List <LinkItem> >()
};
GenerateReferenceInternal(symbol, reference, adapter);
var originalSymbol = symbol;
var reducedFrom = (symbol as IMethodSymbol)?.ReducedFrom;
if (reducedFrom != null)
{
originalSymbol = reducedFrom;
}
reference.IsDefinition = (originalSymbol == symbol) && (id == rawId) && (symbol.IsDefinition || VisitorHelper.GetId(symbol.OriginalDefinition) == rawId);
if (!reference.IsDefinition.Value && rawId != null)
{
reference.Definition = AddReference(originalSymbol.OriginalDefinition, references, adapter);
}
reference.Parent = GetReferenceParent(originalSymbol, typeGenericParameters, methodGenericParameters, references, adapter);
reference.CommentId = VisitorHelper.GetCommentId(originalSymbol);
if (!references.ContainsKey(id))
{
references[id] = reference;
}
else
{
references[id].Merge(reference);
}
return(id);
}
public override void VisitMethod(IMethodSymbol symbol)
{
var id = _asOverload ? VisitorHelper.GetOverloadId(symbol.OriginalDefinition) : VisitorHelper.GetId(symbol.OriginalDefinition);
ReferenceItem.Parts[SyntaxLanguage.VB].Add(new LinkItem
{
DisplayName = NameVisitorCreator.GetVB(_asOverload ? NameOptions.WithMethodGenericParameter : NameOptions.WithGenericParameter).GetName(symbol),
DisplayNamesWithType = NameVisitorCreator.GetVB(NameOptions.WithType | (_asOverload ? NameOptions.WithMethodGenericParameter : NameOptions.WithGenericParameter)).GetName(symbol),
DisplayQualifiedNames = NameVisitorCreator.GetVB(NameOptions.Qualified | (_asOverload ? NameOptions.WithMethodGenericParameter : NameOptions.WithGenericParameter)).GetName(symbol),
Name = id,
IsExternalPath = symbol.IsExtern || symbol.DeclaringSyntaxReferences.Length == 0,
});
if (_asOverload)
{
return;
}
ReferenceItem.Parts[SyntaxLanguage.VB].Add(new LinkItem
{
DisplayName = "(",
DisplayNamesWithType = "(",
DisplayQualifiedNames = "(",
});
for (int i = 0; i < symbol.Parameters.Length; i++)
{
if (i > 0)
{
ReferenceItem.Parts[SyntaxLanguage.VB].Add(new LinkItem
{
DisplayName = ", ",
DisplayNamesWithType = ", ",
DisplayQualifiedNames = ", ",
});
}
symbol.Parameters[i].Type.Accept(this);
}
ReferenceItem.Parts[SyntaxLanguage.VB].Add(new LinkItem
{
DisplayName = ")",
DisplayNamesWithType = ")",
DisplayQualifiedNames = ")",
});
}
private static string GetLiteralString(TypedConstant constant)
{
if (constant.Kind == TypedConstantKind.Enum)
{
var namedType = (INamedTypeSymbol)constant.Type;
var name = (from member in namedType.GetMembers().OfType <IFieldSymbol>()
where member.IsConst && member.HasConstantValue
where constant.Value.Equals(member.ConstantValue)
select member.Name).FirstOrDefault();
if (name != null)
{
return($"{VisitorHelper.GetId(namedType)}.{name}");
}
// todo : define filter data format (language neutral), just use number for combine case by now.
// e.g.: [Flags] public enum E { X=1,Y=2,Z=4,YZ=6 }
// Case: [E(E.X | E.Y)]
// Case: [E((E)99)]
// Case: [E(E.X | E.YZ)]
return(constant.Value.ToString());
}
if (constant.Kind == TypedConstantKind.Array)
{
if (constant.Values.IsDefaultOrEmpty)
{
return("");
}
return(string.Join(",", constant.Values.Select(GetLiteralString)));
}
var value = constant.Value;
if (value is ISymbol)
{
return(VisitorHelper.GetId(constant.Value as ISymbol));
}
return(value?.ToString() ?? "null");
}
internal string AddSpecReference(
ISymbol symbol,
IReadOnlyList <string> typeGenericParameters,
IReadOnlyList <string> methodGenericParameters,
Dictionary <string, ReferenceItem> references,
SymbolVisitorAdapter adapter)
{
var rawId = VisitorHelper.GetId(symbol);
var id = SpecIdHelper.GetSpecId(symbol, typeGenericParameters, methodGenericParameters);
ReferenceItem reference = new ReferenceItem();
reference.Parts = new SortedList <SyntaxLanguage, List <LinkItem> >();
GenerateReferenceInternal(symbol, reference, adapter);
var originalSymbol = symbol;
var reducedFrom = (symbol as IMethodSymbol)?.ReducedFrom;
if (reducedFrom != null)
{
originalSymbol = reducedFrom;
}
reference.IsDefinition = (originalSymbol == symbol) && (id == rawId) && symbol.IsDefinition;
if (!reference.IsDefinition.Value && rawId != null)
{
reference.Definition = AddReference(originalSymbol.OriginalDefinition, references, adapter);
}
reference.Parent = GetReferenceParent(originalSymbol, typeGenericParameters, methodGenericParameters, references, adapter);
reference.CommentId = VisitorHelper.GetCommentId(originalSymbol);
if (!references.ContainsKey(id))
{
references[id] = reference;
}
else
{
references[id].Merge(reference);
}
return(id);
}
public override void VisitProperty(IPropertySymbol symbol)
{
var id = _asOverload ? VisitorHelper.GetOverloadId(symbol.OriginalDefinition) : VisitorHelper.GetId(symbol.OriginalDefinition);
ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem
{
DisplayName = NameVisitorCreator.GetCSharp(NameOptions.WithTypeGenericParameter).GetName(symbol),
DisplayNamesWithType = NameVisitorCreator.GetCSharp(NameOptions.WithType | NameOptions.WithTypeGenericParameter).GetName(symbol),
DisplayQualifiedNames = NameVisitorCreator.GetCSharp(NameOptions.Qualified | NameOptions.WithTypeGenericParameter).GetName(symbol),
Name = id,
IsExternalPath = symbol.IsExtern || symbol.DeclaringSyntaxReferences.Length == 0,
});
if (symbol.Parameters.Length > 0 && !_asOverload)
{
ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem
{
DisplayName = "[",
DisplayNamesWithType = "[",
DisplayQualifiedNames = "[",
});
for (int i = 0; i < symbol.Parameters.Length; i++)
{
if (i > 0)
{
ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem
{
DisplayName = ", ",
DisplayNamesWithType = ", ",
DisplayQualifiedNames = ", ",
});
}
symbol.Parameters[i].Type.Accept(this);
}
ReferenceItem.Parts[SyntaxLanguage.CSharp].Add(new LinkItem
{
DisplayName = "]",
DisplayNamesWithType = "]",
DisplayQualifiedNames = "]",
});
}
}
internal string AddReference(ISymbol symbol, Dictionary <string, ReferenceItem> references, SymbolVisitorAdapter adapter)
{
var id = VisitorHelper.GetId(symbol);
ReferenceItem reference = new ReferenceItem();
reference.Parts = new SortedList <SyntaxLanguage, List <LinkItem> >();
reference.IsDefinition = symbol.IsDefinition;
GenerateReferenceInternal(symbol, reference, adapter);
if (!references.ContainsKey(id))
{
references[id] = reference;
}
else
{
references[id].Merge(reference);
}
return(id);
}
public override MetadataItem VisitAssembly(IAssemblySymbol symbol)
{
var item = new MetadataItem
{
Name = VisitorHelper.GetId(symbol),
RawComment = symbol.GetDocumentationCommentXml(),
Language = Language,
};
item.DisplayNames = new SortedList <SyntaxLanguage, string>
{
{ SyntaxLanguage.Default, symbol.MetadataName },
};
item.DisplayQualifiedNames = new SortedList <SyntaxLanguage, string>
{
{ SyntaxLanguage.Default, symbol.MetadataName },
};
item.Type = MemberType.Assembly;
_references = new Dictionary <string, ReferenceItem>();
IEnumerable <INamespaceSymbol> namespaces;
if (!string.IsNullOrEmpty(VisitorHelper.GlobalNamespaceId))
{
namespaces = Enumerable.Repeat(symbol.GlobalNamespace, 1);
}
else
{
namespaces = symbol.GlobalNamespace.GetNamespaceMembers();
}
item.Items = VisitDescendants(
namespaces,
ns => ns.GetMembers().OfType <INamespaceSymbol>(),
ns => ns.GetMembers().OfType <INamedTypeSymbol>().Any(t => FilterVisitor.CanVisitApi(t)));
item.References = _references;
return(item);
}
private static string GetLiteralString(TypedConstant constant)
{
var type = constant.Type;
var value = constant.Value;
if (type.TypeKind == TypeKind.Enum)
{
var namedType = (INamedTypeSymbol)type;
var pairs = (from member in namedType.GetMembers().OfType <IFieldSymbol>()
where member.IsConst && member.HasConstantValue
select Tuple.Create(member.Name, member.ConstantValue)).ToDictionary(tuple => tuple.Item2, tuple => tuple.Item1);
return($"{VisitorHelper.GetId(namedType)}.{pairs[value]}");
}
if (value is ITypeSymbol)
{
return(VisitorHelper.GetId((ITypeSymbol)value));
}
return(value.ToString());
}
public override MetadataItem VisitEvent(IEventSymbol symbol)
{
MetadataItem result = GetYamlItem(symbol);
if (result == null)
{
return(null);
}
if (result.Syntax == null)
{
result.Syntax = new SyntaxDetail {
Content = new SortedList <SyntaxLanguage, string>()
};
}
if (result.Syntax.Content == null)
{
result.Syntax.Content = new SortedList <SyntaxLanguage, string>();
}
_generator.GenerateSyntax(result.Type, symbol, result.Syntax, this);
_generator.GenerateEvent(symbol, result, this);
var typeGenericParameters = symbol.ContainingType.IsGenericType ? symbol.ContainingType.Accept(TypeGenericParameterNameVisitor.Instance) : EmptyListOfString;
if (symbol.IsOverride && symbol.OverriddenEvent != null)
{
result.Overridden = AddSpecReference(symbol.OverriddenEvent, typeGenericParameters);
}
var id = AddSpecReference(symbol.Type, typeGenericParameters);
result.Syntax.Return = VisitorHelper.GetParameterDescription(symbol, result, id, true, GetTripleSlashCommentParserContext(result, _preserveRawInlineComments));
Debug.Assert(result.Syntax.Return.Type != null);
result.Attributes = GetAttributeInfo(symbol.GetAttributes());
return(result);
}
public override MetadataItem VisitAssembly(IAssemblySymbol symbol)
{
var item = new MetadataItem
{
Name = VisitorHelper.GetId(symbol),
RawComment = symbol.GetDocumentationCommentXml(),
Language = Language,
};
item.DisplayNames = new SortedList <SyntaxLanguage, string>
{
{ SyntaxLanguage.Default, symbol.MetadataName },
};
item.DisplayQualifiedNames = new SortedList <SyntaxLanguage, string>
{
{ SyntaxLanguage.Default, symbol.MetadataName },
};
item.Type = MemberType.Assembly;
_references = new Dictionary <string, ReferenceItem>();
var typeMembers = symbol.GlobalNamespace.GetTypeMembers();
if (typeMembers.Any())
{
Logger.LogWarning($"DocFX currently only supports generating metadata with namespace defined. The following types in assembly \"{symbol.MetadataName}\" will have no metadata generated: {string.Join(", ", typeMembers.Select(m => m.MetadataName))}. ");
}
var namespaces = symbol.GlobalNamespace.GetNamespaceMembers().ToList();
item.Items = VisitDescendants(
namespaces,
ns => ns.GetMembers().OfType <INamespaceSymbol>(),
ns => ns.GetMembers().OfType <INamedTypeSymbol>().Any(t => FilterVisitor.CanVisitApi(t)));
item.References = _references;
return(item);
}
internal string AddOverloadReference(ISymbol symbol, Dictionary <string, ReferenceItem> references, SymbolVisitorAdapter adapter)
{
string uidBody = VisitorHelper.GetOverloadIdBody(symbol);
ReferenceItem reference = new ReferenceItem();
reference.Parts = new SortedList <SyntaxLanguage, List <LinkItem> >();
reference.IsDefinition = true;
reference.CommentId = "Overload:" + uidBody;
GenerateReferenceInternal(symbol, reference, adapter, true);
var uid = uidBody + "*";
if (!references.ContainsKey(uid))
{
references[uid] = reference;
}
else
{
references[uid].Merge(reference);
}
return(uid);
}
/// <summary>
/// return a symbol in the assigned container
/// </summary>
/// <param name="container">container</param>
/// <param name="symbol">symbol</param>
/// <returns>related symbol in the compilation</returns>
public static ISymbol FindSymbol(this INamespaceOrTypeSymbol container, ISymbol symbol)
{
return(FindCore(container, GetQualifiedNameList(symbol)).Where(m => VisitorHelper.GetCommentId(m) == VisitorHelper.GetCommentId(symbol)).FirstOrDefault());
}
private MemberType GetMemberTypeFromSymbol(ISymbol symbol)
{
switch (symbol.Kind)
{
case SymbolKind.Namespace:
return(MemberType.Namespace);
case SymbolKind.NamedType:
INamedTypeSymbol nameTypeSymbol = symbol as INamedTypeSymbol;
Debug.Assert(nameTypeSymbol != null);
if (nameTypeSymbol != null)
{
return(VisitorHelper.GetMemberTypeFromTypeKind(nameTypeSymbol.TypeKind));
}
else
{
return(MemberType.Default);
}
case SymbolKind.Event:
return(MemberType.Event);
case SymbolKind.Field:
return(MemberType.Field);
case SymbolKind.Property:
return(MemberType.Property);
case SymbolKind.Method:
{
var methodSymbol = symbol as IMethodSymbol;
Debug.Assert(methodSymbol != null);
if (methodSymbol == null)
{
return(MemberType.Default);
}
switch (methodSymbol.MethodKind)
{
case MethodKind.AnonymousFunction:
case MethodKind.DelegateInvoke:
case MethodKind.Destructor:
case MethodKind.ExplicitInterfaceImplementation:
case MethodKind.Ordinary:
case MethodKind.ReducedExtension:
case MethodKind.DeclareMethod:
return(MemberType.Method);
case MethodKind.BuiltinOperator:
case MethodKind.UserDefinedOperator:
case MethodKind.Conversion:
return(MemberType.Operator);
case MethodKind.Constructor:
case MethodKind.StaticConstructor:
return(MemberType.Constructor);
// ignore: Property's get/set, and event's add/remove/raise
case MethodKind.PropertyGet:
case MethodKind.PropertySet:
case MethodKind.EventAdd:
case MethodKind.EventRemove:
case MethodKind.EventRaise:
default:
return(MemberType.Default);
}
}
default:
return(MemberType.Default);
}
}
public override MetadataItem VisitNamedType(INamedTypeSymbol symbol)
{
var item = DefaultVisit(symbol);
if (item == null)
{
return(null);
}
GenerateInheritance(symbol, item);
item.Type = VisitorHelper.GetMemberTypeFromTypeKind(symbol.TypeKind);
if (item.Syntax == null)
{
item.Syntax = new SyntaxDetail {
Content = new SortedList <SyntaxLanguage, string>()
};
}
if (item.Syntax.Content == null)
{
item.Syntax.Content = new SortedList <SyntaxLanguage, string>();
}
_generator.GenerateSyntax(item.Type, symbol, item.Syntax, this);
if (symbol.TypeParameters.Length > 0)
{
if (item.Syntax.TypeParameters == null)
{
item.Syntax.TypeParameters = new List <ApiParameter>();
}
foreach (var p in symbol.TypeParameters)
{
var param = VisitorHelper.GetTypeParameterDescription(p, item, GetTripleSlashCommentParserContext(item, _preserveRawInlineComments));
item.Syntax.TypeParameters.Add(param);
}
}
if (symbol.TypeKind == TypeKind.Delegate)
{
var typeGenericParameters = symbol.IsGenericType ? symbol.Accept(TypeGenericParameterNameVisitor.Instance) : EmptyListOfString;
AddMethodSyntax(symbol.DelegateInvokeMethod, item, typeGenericParameters, EmptyListOfString);
}
_generator.GenerateNamedType(symbol, item, this);
item.Items = new List <MetadataItem>();
foreach (var member in symbol.GetMembers().Where(s => !(s is INamedTypeSymbol)))
{
var memberItem = member.Accept(this);
if (memberItem != null)
{
item.Items.Add(memberItem);
}
}
AddReference(symbol);
item.Attributes = GetAttributeInfo(symbol.GetAttributes());
return(item);
}
public override string DefaultVisit(ISymbol symbol)
{
return(VisitorHelper.GetId(symbol));
}
public override void VisitNamedType(INamedTypeSymbol symbol)
{
if ((Options & NameOptions.UseAlias) == NameOptions.UseAlias &&
TrySpecialType(symbol))
{
return;
}
if (symbol.ContainingType != null)
{
symbol.ContainingType.Accept(this);
Append(".");
}
else if ((Options & NameOptions.WithNamespace) == NameOptions.WithNamespace)
{
if (!VisitorHelper.InGlobalNamespace(symbol))
{
symbol.ContainingNamespace.Accept(this);
Append(".");
}
}
if (symbol.IsTupleType)
{
if ((Options & NameOptions.Qualified) == NameOptions.Qualified)
{
Append("ValueTuple");
symbol = symbol.TupleUnderlyingType ?? symbol;
}
else
{
Append("(");
for (var i = 0; i < symbol.TupleElements.Length; i++)
{
if (i > 0)
{
Append(", ");
}
var tupleElement = symbol.TupleElements[i];
if (!tupleElement.IsImplicitlyDeclared)
{
Append(tupleElement.Name);
Append(" As ");
}
tupleElement.Type.Accept(this);
}
Append(")");
}
}
else
{
Append(symbol.Name);
}
if ((Options & NameOptions.WithTypeGenericParameter) == NameOptions.WithTypeGenericParameter &&
symbol.TypeParameters.Length > 0)
{
if (symbol.TypeArguments != null && symbol.TypeArguments.Length > 0)
{
if (symbol.IsUnboundGenericType)
{
WriteGeneric(symbol.TypeArguments.Length);
}
else
{
WriteGeneric(symbol.TypeArguments);
}
}
else
{
WriteGeneric(symbol.TypeParameters);
}
}
}
