/// <summary>
/// e.g. Classes
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private string CheckNamespaceMembers(MetadataItem member)
{
StringBuilder message = new StringBuilder();
// Skip if it is already invalid
if (member.Items == null || member.IsInvalid)
{
return string.Empty;
}
foreach (var i in member.Items)
{
Debug.Assert(!i.Type.IsPageLevel());
if (i.Type.IsPageLevel())
{
Logger.Log(LogLevel.Error, $"Invalid item inside yaml metadata: {i.Type.ToString()} is not allowed inside {member.Type.ToString()}. Will be ignored.");
message.AppendFormat("{0} is not allowed inside {1}.", i.Type.ToString(), member.Type.ToString());
i.IsInvalid = true;
}
else
{
var result = CheckNamespaceMembersMembers(i);
if (!string.IsNullOrEmpty(result))
{
message.AppendLine(result);
}
}
}
return message.ToString();
}
public override void GenerateNamedType(INamedTypeSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateNamedType(symbol, item, adapter);
var modifiers = new List<string>();
var visiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (visiblity != null)
{
modifiers.Add(visiblity);
}
if (symbol.TypeKind == TypeKind.Class)
{
if (symbol.IsAbstract)
{
modifiers.Add("MustInherit");
}
else if (symbol.IsSealed)
{
modifiers.Add("NotInheritable");
}
}
switch (symbol.TypeKind)
{
case TypeKind.Module:
modifiers.Add("Module");
break;
case TypeKind.Class:
if (symbol.IsStatic)
{
modifiers.Add("Module");
}
else
{
modifiers.Add("Class");
}
break;
case TypeKind.Delegate:
modifiers.Add("Delegate");
break;
case TypeKind.Enum:
modifiers.Add("Enum");
break;
case TypeKind.Interface:
modifiers.Add("Interface");
break;
case TypeKind.Struct:
modifiers.Add("Structure");
break;
default:
break;
}
item.Modifiers[SyntaxLanguage.VB] = modifiers;
}
public static void FeedComments(MetadataItem item, ITripleSlashCommentParserContext context)
{
if (!string.IsNullOrEmpty(item.RawComment))
{
var commentModel = TripleSlashCommentModel.CreateModel(item.RawComment, item.Language, context);
if (commentModel == null) return;
item.Summary = commentModel.Summary;
item.Remarks = commentModel.Remarks;
item.Exceptions = commentModel.Exceptions;
item.Sees = commentModel.Sees;
item.SeeAlsos = commentModel.SeeAlsos;
item.Examples = commentModel.Examples;
item.CommentModel = commentModel;
}
}
private void AddIndirectReference(ResolverContext context, MetadataItem page, List<ReferenceItem> addedReferences)
{
while (addedReferences.Count > 0)
{
var addingReferences = new List<ReferenceItem>();
foreach (var r in addedReferences)
{
foreach (var key in GetReferenceKeys(r))
{
TryAddReference(context, page, addingReferences, key);
}
}
addedReferences = addingReferences;
}
}
private static bool TryParseYamlMetadataFile(string metadataFileName, out MetadataItem projectMetadata)
{
projectMetadata = null;
try
{
using (StreamReader reader = new StreamReader(metadataFileName))
{
projectMetadata = YamlUtility.Deserialize <MetadataItem>(reader);
return(true);
}
}
catch (Exception e)
{
Logger.LogInfo($"Error parsing yaml metadata file: {e.Message}");
return(false);
}
}
private static void TryAddReference(ResolverContext context, MetadataItem page, List <ReferenceItem> addingReferences, string key)
{
if (!page.References.ContainsKey(key))
{
ReferenceItem item;
if (context.References.TryGetValue(key, out item))
{
var reference = context.References[key].Clone();
page.References.Add(key, reference);
addingReferences.Add(reference);
}
else
{
Debug.Fail(string.Format("Reference not found: {0}", key));
}
}
}
private static void TryAddReference(ResolverContext context, MetadataItem page, List<ReferenceItem> addingReferences, string key)
{
if (!page.References.ContainsKey(key))
{
ReferenceItem item;
if (context.References.TryGetValue(key, out item))
{
var reference = context.References[key].Clone();
page.References.Add(key, reference);
addingReferences.Add(reference);
}
else
{
Debug.Fail(string.Format("Reference not found: {0}", key));
}
}
}
private static bool TryGetItemByCommentId(MetadataItem item, string commentId, ref MetadataItem resultItem)
{
if (string.Equals(item.CommentId, commentId, StringComparison.OrdinalIgnoreCase))
{
resultItem = item;
return(true);
}
foreach (var metadataItem in item.Items ?? Enumerable.Empty <MetadataItem>())
{
if (TryGetItemByCommentId(metadataItem, commentId, ref resultItem))
{
return(true);
}
}
return(false);
}
public static void FeedComments(MetadataItem item, ITripleSlashCommentParserContext context)
{
if (!string.IsNullOrEmpty(item.RawComment))
{
var commentModel = TripleSlashCommentModel.CreateModel(item.RawComment, item.Language, context);
if (commentModel == null)
{
return;
}
item.Summary = commentModel.Summary;
item.Remarks = commentModel.Remarks;
item.Exceptions = commentModel.Exceptions;
item.Sees = commentModel.Sees;
item.SeeAlsos = commentModel.SeeAlsos;
item.Examples = commentModel.Examples;
item.CommentModel = commentModel;
}
}
/// <summary>
/// Only when Namespace is not empty, return it
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public static MetadataItem ShrinkToSimpleTocWithNamespaceNotEmpty(this MetadataItem item)
{
MetadataItem shrinkedItem = new MetadataItem
{
Name = item.Name,
DisplayNames = item.DisplayNames,
Type = item.Type,
Items = null
};
if (item.Type == MemberType.Toc || item.Type == MemberType.Namespace)
{
if (item.Items != null)
{
foreach (var i in item.Items)
{
if (shrinkedItem.Items == null)
{
shrinkedItem.Items = new List <MetadataItem>();
}
if (i.IsInvalid)
{
continue;
}
var shrinkedI = i.ShrinkToSimpleTocWithNamespaceNotEmpty();
if (shrinkedI != null)
{
shrinkedItem.Items.Add(shrinkedI);
}
}
}
}
if (item.Type == MemberType.Namespace)
{
if (shrinkedItem.Items == null || shrinkedItem.Items.Count == 0)
{
return(null);
}
}
return(shrinkedItem);
}
public static PageViewModel ToPageViewModel(this MetadataItem model)
{
if (model == null)
{
return(null);
}
var result = new PageViewModel();
result.Items.Add(model.ToItemViewModel());
if (model.Type.AllowMultipleItems())
{
AddChildren(model, result);
}
foreach (var item in model.References)
{
result.References.Add(item.ToReferenceViewModel());
}
return(result);
}
public void CopyInheritedData(MetadataItem src)
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
if (Summary == null)
{
Summary = src.Summary;
}
if (Remarks == null)
{
Remarks = src.Remarks;
}
if (Exceptions == null && src.Exceptions != null)
{
Exceptions = src.Exceptions.Select(e => e.Clone()).ToList();
}
if (Sees == null && src.Sees != null)
{
Sees = src.Sees.Select(s => s.Clone()).ToList();
}
if (SeeAlsos == null && src.SeeAlsos != null)
{
SeeAlsos = src.SeeAlsos.Select(s => s.Clone()).ToList();
}
if (Examples == null && src.Examples != null)
{
Examples = new List <string>(src.Examples);
}
if (CommentModel != null && src.CommentModel != null)
{
CommentModel.CopyInheritedData(src.CommentModel);
}
if (Syntax != null && src.Syntax != null)
{
Syntax.CopyInheritedData(src.Syntax);
}
}
public static TocViewModel ToTocViewModel(this MetadataItem item)
{
if (item == null)
{
Debug.Fail("item is null.");
return(null);
}
switch (item.Type)
{
case MemberType.Toc:
case MemberType.Namespace:
var result = new List <TocItemViewModel>();
foreach (var child in item.Items)
{
result.Add(child.ToTocItemViewModel());
}
return(new TocViewModel(result.OrderBy(s => s.Name)));
default:
return(null);
}
}
private static void AddMemberToIndexer(MetadataItem memberModel, string outputPath, ApiReferenceViewModel indexer)
{
if (memberModel.Type == MemberType.Namespace)
{
indexer.Add(memberModel.Name, outputPath);
}
else
{
TreeIterator.Preorder(memberModel, null, s => s.Items, (member, parent) =>
{
if (indexer.TryGetValue(member.Name, out string path))
{
Logger.LogWarning($"{member.Name} already exists in {path}, the duplicate one {outputPath} will be ignored.");
}
else
{
indexer.Add(member.Name, outputPath);
}
return(true);
});
}
}
public override void GenerateMethod(IMethodSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateMethod(symbol, item, adapter);
var modifiers = new List<string>();
if (symbol.ContainingType.TypeKind != TypeKind.Interface)
{
var visiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (visiblity != null)
{
modifiers.Add(visiblity);
}
if (symbol.IsStatic)
{
modifiers.Add("static");
}
if (symbol.IsAbstract)
{
modifiers.Add("abstract");
}
if (symbol.IsOverride)
{
modifiers.Add("override");
}
if (symbol.IsVirtual && symbol.IsSealed)
{
}
else if (symbol.IsVirtual)
{
modifiers.Add("virtual");
}
else if (symbol.IsSealed)
{
modifiers.Add("sealed");
}
}
item.Modifiers[SyntaxLanguage.CSharp] = modifiers;
}
/// <summary>
/// e.g. Methods
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private string CheckNamespaceMembersMembers(MetadataItem member)
{
StringBuilder message = new StringBuilder();
if (member.IsInvalid)
{
return(string.Empty);
}
// does method has members?
Debug.Assert(member.Items == null);
if (member.Items != null)
{
foreach (var i in member.Items)
{
i.IsInvalid = true;
}
Logger.Log(LogLevel.Error, $"Invalid item inside yaml metadata: {member.Type.ToString()} should not contain items. Will be ignored.");
message.AppendFormat("{0} should not contain items.", member.Type.ToString());
}
return(message.ToString());
}
public virtual void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public virtual void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public override void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateProperty(symbol, item, adapter);
var modifiers = new List<string>();
var propertyVisiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (symbol.ContainingType.TypeKind != TypeKind.Interface)
{
if (propertyVisiblity != null)
{
modifiers.Add(propertyVisiblity);
}
if (symbol.IsStatic)
{
modifiers.Add("static");
}
if (symbol.IsAbstract)
{
modifiers.Add("abstract");
}
if (symbol.IsOverride)
{
modifiers.Add("override");
}
if (symbol.IsVirtual && symbol.IsSealed)
{
}
else if (symbol.IsVirtual)
{
modifiers.Add("virtual");
}
else if (symbol.IsSealed)
{
modifiers.Add("sealed");
}
}
if (symbol.GetMethod != null)
{
var getMethodVisiblity = GetVisiblity(symbol.GetMethod.DeclaredAccessibility);
if (propertyVisiblity != null && getMethodVisiblity == null)
{
}
else if (getMethodVisiblity != propertyVisiblity)
{
modifiers.Add($"{getMethodVisiblity} get");
}
else
{
modifiers.Add("get");
}
}
if (symbol.SetMethod != null)
{
var setMethodVisiblity = GetVisiblity(symbol.SetMethod.DeclaredAccessibility);
if (propertyVisiblity != null && setMethodVisiblity == null)
{
}
else if (setMethodVisiblity != propertyVisiblity)
{
modifiers.Add($"{setMethodVisiblity} set");
}
else
{
modifiers.Add("set");
}
}
item.Modifiers[SyntaxLanguage.CSharp] = modifiers;
}
public static ApiParameter GetTypeParameterDescription(ITypeParameterSymbol symbol, MetadataItem item, ITripleSlashCommentParserContext context)
{
string comment = item.CommentModel?.GetTypeParameter(symbol.Name);
return(new ApiParameter
{
Name = symbol.Name,
Description = comment,
});
}
public virtual void GenerateMethod(IMethodSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
static void InheritDoc(MetadataItem dest, ResolverContext context)
{
dest.IsInheritDoc = false;
switch (dest.Type)
{
case MemberType.Constructor:
if (dest.Parent == null || dest.Syntax == null || dest.Syntax.Parameters == null)
{
return;
}
Debug.Assert(dest.Parent.Type == MemberType.Class);
//try to find the base class
if (dest.Parent.Inheritance?.Count == 0)
{
return;
}
MetadataItem baseClass;
if (!context.Members.TryGetValue(dest.Parent.Inheritance[dest.Parent.Inheritance.Count - 1], out baseClass))
{
return;
}
if (baseClass.Items == null)
{
return;
}
//look a constructor in the base class which has a matching signature
foreach (var ctor in baseClass.Items)
{
if (ctor.Type != MemberType.Constructor)
{
continue;
}
if (ctor.Syntax == null || ctor.Syntax.Parameters == null)
{
continue;
}
if (ctor.Syntax.Parameters.Count != dest.Syntax.Parameters.Count)
{
continue;
}
bool parametersMatch = true;
for (int ndx = 0; ndx < dest.Syntax.Parameters.Count; ndx++)
{
var myParam = dest.Syntax.Parameters[ndx];
var baseParam = ctor.Syntax.Parameters[ndx];
if (myParam.Name != baseParam.Name)
{
parametersMatch = false;
}
if (myParam.Type != baseParam.Type)
{
parametersMatch = false;
}
}
if (parametersMatch)
{
Copy(dest, ctor, context);
return;
}
}
break;
case MemberType.Method:
case MemberType.Property:
case MemberType.Event:
Copy(dest, dest.Overridden, context);
if (dest.Implements != null)
{
foreach (var item in dest.Implements)
{
Copy(dest, item, context);
}
}
break;
case MemberType.Class:
if (dest.Inheritance.Count != 0)
{
Copy(dest, dest.Inheritance[dest.Inheritance.Count - 1], context);
}
if (dest.Implements != null)
{
foreach (var item in dest.Implements)
{
Copy(dest, item, context);
}
}
break;
}
}
public static ApiParameter GetParameterDescription(ISymbol symbol, MetadataItem item, string id, bool isReturn, ITripleSlashCommentParserContext context)
{
string comment = isReturn ? item.CommentModel?.Returns : item.CommentModel?.GetParameter(symbol.Name);
return new ApiParameter
{
Name = isReturn ? null : symbol.Name,
Type = id,
Description = comment,
};
}
/// <summary>
/// e.g. Methods
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
private string CheckNamespaceMembersMembers(MetadataItem member)
{
StringBuilder message = new StringBuilder();
if (member.IsInvalid)
{
return string.Empty;
}
// does method has members?
Debug.Assert(member.Items == null);
if (member.Items != null)
{
foreach (var i in member.Items)
{
i.IsInvalid = true;
}
Logger.Log(LogLevel.Error, $"Invalid item inside yaml metadata: {member.Type.ToString()} should not contain items. Will be ignored.");
message.AppendFormat("{0} should not contain items.", member.Type.ToString());
}
return message.ToString();
}
public static ApiParameter GetTypeParameterDescription(ITypeParameterSymbol symbol, MetadataItem item, ITripleSlashCommentParserContext context)
{
string comment = item.CommentModel?.GetTypeParameter(symbol.Name);
return new ApiParameter
{
Name = symbol.Name,
Description = comment,
};
}
public virtual void GenerateField(IFieldSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
private IEnumerable <string> GetReferenceKeys(MetadataItem current)
{
if (current.NamespaceName != null)
{
yield return(current.NamespaceName);
}
if (current.Overridden != null)
{
yield return(current.Overridden);
}
if (current.Overload != null)
{
yield return(current.Overload);
}
if (current.Inheritance?.Count > 0)
{
foreach (var item in current.Inheritance)
{
yield return(item);
}
}
if (current.Implements?.Count > 0)
{
foreach (var item in current.Implements)
{
yield return(item);
}
}
if (current.DerivedClasses?.Count > 0)
{
foreach (var item in current.DerivedClasses)
{
yield return(item);
}
}
if (current.InheritedMembers?.Count > 0)
{
foreach (var item in current.InheritedMembers)
{
yield return(item);
}
}
if (current.ExtensionMethods?.Count > 0)
{
foreach (var item in current.ExtensionMethods)
{
yield return(item);
}
}
if (current.Exceptions?.Count > 0)
{
foreach (var item in current.Exceptions)
{
yield return(item.Type);
}
}
if (current.Sees?.Count > 0)
{
foreach (var item in current.Sees.Where(l => l.LinkType == LinkType.CRef))
{
yield return(item.LinkId);
}
}
if (current.SeeAlsos?.Count > 0)
{
foreach (var item in current.SeeAlsos.Where(l => l.LinkType == LinkType.CRef))
{
yield return(item.LinkId);
}
}
if (current.Syntax != null)
{
if (current.Syntax.Parameters?.Count > 0)
{
foreach (var item in current.Syntax.Parameters)
{
yield return(item.Type);
}
}
if (current.Syntax.Return != null)
{
yield return(current.Syntax.Return.Type);
}
}
}
public virtual void GenerateEvent(IEventSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public virtual void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
private IEnumerable<string> GetReferenceKeys(MetadataItem current)
{
if (current.NamespaceName != null)
{
yield return current.NamespaceName;
}
if (current.Overridden != null)
{
yield return current.Overridden;
}
if (current.Overload != null)
{
yield return current.Overload;
}
if (current.Inheritance?.Count > 0)
{
foreach (var item in current.Inheritance)
{
yield return item;
}
}
if (current.Implements?.Count > 0)
{
foreach (var item in current.Implements)
{
yield return item;
}
}
if (current.InheritedMembers?.Count > 0)
{
foreach (var item in current.InheritedMembers)
{
yield return item;
}
}
if (current.ExtensionMethods?.Count > 0)
{
foreach (var item in current.ExtensionMethods)
{
yield return item;
}
}
if (current.Exceptions?.Count > 0)
{
foreach (var item in current.Exceptions)
{
yield return item.Type;
}
}
if (current.Sees?.Count > 0)
{
foreach (var item in current.Sees.Where(l => l.LinkType == LinkType.CRef))
{
yield return item.LinkId;
}
}
if (current.SeeAlsos?.Count > 0)
{
foreach (var item in current.SeeAlsos.Where(l => l.LinkType == LinkType.CRef))
{
yield return item.LinkId;
}
}
if (current.Syntax != null)
{
if (current.Syntax.Parameters?.Count > 0)
{
foreach (var item in current.Syntax.Parameters)
{
yield return item.Type;
}
}
if (current.Syntax.Return != null)
{
yield return current.Syntax.Return.Type;
}
}
}
private IEnumerable <string> GetReferenceKeys(MetadataItem current)
{
if (current.NamespaceName != null)
{
yield return(current.NamespaceName);
}
if (current.Overridden != null)
{
yield return(current.Overridden);
}
if (current.Inheritance?.Count > 0)
{
foreach (var item in current.Inheritance)
{
yield return(item);
}
}
if (current.Implements?.Count > 0)
{
foreach (var item in current.Implements)
{
yield return(item);
}
}
if (current.InheritedMembers?.Count > 0)
{
foreach (var item in current.InheritedMembers)
{
yield return(item);
}
}
if (current.Exceptions?.Count > 0)
{
foreach (var item in current.Exceptions)
{
yield return(item.Type);
}
}
if (current.Sees?.Count > 0)
{
foreach (var item in current.Sees)
{
yield return(item.Type);
}
}
if (current.SeeAlsos?.Count > 0)
{
foreach (var item in current.SeeAlsos)
{
yield return(item.Type);
}
}
if (current.Syntax != null)
{
if (current.Syntax.Parameters?.Count > 0)
{
foreach (var item in current.Syntax.Parameters)
{
yield return(item.Type);
}
}
if (current.Syntax.Return != null)
{
yield return(current.Syntax.Return.Type);
}
}
}
public override void GenerateEvent(IEventSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateEvent(symbol, item, adapter);
var modifiers = new List<string>();
if (symbol.ContainingType.TypeKind != TypeKind.Interface)
{
var visiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (visiblity != null)
{
modifiers.Add(visiblity);
}
if (symbol.IsStatic)
{
modifiers.Add("Shared");
}
if (symbol.IsAbstract)
{
modifiers.Add("MustOverride");
}
if (symbol.IsOverride)
{
modifiers.Add("Overrides");
}
if (symbol.IsVirtual && symbol.IsSealed)
{
}
else if (symbol.IsVirtual)
{
modifiers.Add("Overridable");
}
else if (symbol.IsSealed)
{
modifiers.Add("NotOverridable");
}
}
item.Modifiers[SyntaxLanguage.VB] = modifiers;
}
public override void GenerateField(IFieldSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateField(symbol, item, adapter);
var modifiers = new List<string>();
var visiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (visiblity != null)
{
modifiers.Add(visiblity);
}
if (symbol.IsConst)
{
modifiers.Add("const");
}
else if (symbol.IsStatic)
{
modifiers.Add("static");
}
if (symbol.IsReadOnly)
{
modifiers.Add("readonly");
}
if (symbol.IsVolatile)
{
modifiers.Add("volatile");
}
item.Modifiers[SyntaxLanguage.CSharp] = modifiers;
}
public virtual void GenerateNamedType(INamedTypeSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public override void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
item.DisplayNames[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol);
item.DisplayNamesWithType[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.WithType | NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol);
item.DisplayQualifiedNames[SyntaxLanguage.CSharp] = NameVisitorCreator.GetCSharp(NameOptions.Qualified | NameOptions.WithGenericParameter | NameOptions.WithParameter).GetName(symbol);
}
public virtual void DefaultVisit(ISymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public virtual void GenerateNamedType(INamedTypeSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public virtual void GenerateMethod(IMethodSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
public static ItemViewModel ToItemViewModel(this MetadataItem model)
{
if (model == null)
{
return(null);
}
var result = new ItemViewModel
{
Uid = model.Name,
CommentId = model.CommentId,
IsExplicitInterfaceImplementation = model.IsExplicitInterfaceImplementation,
IsExtensionMethod = model.IsExtensionMethod,
Parent = model.Parent?.Name,
Children = model.Items?.Select(x => x.Name).OrderBy(s => s).ToList(),
Type = model.Type,
Source = model.Source,
Documentation = model.Documentation,
AssemblyNameList = model.AssemblyNameList,
NamespaceName = model.NamespaceName,
Summary = model.Summary,
Remarks = model.Remarks,
Examples = model.Examples,
Syntax = model.Syntax.ToSyntaxDetailViewModel(),
Overridden = model.Overridden,
Overload = model.Overload,
Exceptions = model.Exceptions,
Sees = model.Sees,
SeeAlsos = model.SeeAlsos,
Inheritance = model.Inheritance,
Implements = model.Implements,
InheritedMembers = model.InheritedMembers,
ExtensionMethods = model.ExtensionMethods,
Attributes = model.Attributes,
};
result.Id = model.Name.Substring((model.Parent?.Name?.Length ?? -1) + 1);
result.Name = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.Default);
var nameForCSharp = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.CSharp);
if (result.Name != nameForCSharp)
{
result.NameForCSharp = nameForCSharp;
}
var nameForVB = model.DisplayNames.GetLanguageProperty(SyntaxLanguage.VB);
if (result.Name != nameForVB)
{
result.NameForVB = nameForVB;
}
result.NameWithType = model.DisplayNamesWithType.GetLanguageProperty(SyntaxLanguage.Default);
var nameWithTypeForCSharp = model.DisplayNamesWithType.GetLanguageProperty(SyntaxLanguage.CSharp);
if (result.NameWithType != nameWithTypeForCSharp)
{
result.NameWithTypeForCSharp = nameWithTypeForCSharp;
}
var nameWithTypeForVB = model.DisplayNamesWithType.GetLanguageProperty(SyntaxLanguage.VB);
if (result.NameWithType != nameWithTypeForVB)
{
result.NameWithTypeForVB = nameWithTypeForVB;
}
result.FullName = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.Default);
var fullnameForCSharp = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.CSharp);
if (result.FullName != fullnameForCSharp)
{
result.FullNameForCSharp = fullnameForCSharp;
}
var fullnameForVB = model.DisplayQualifiedNames.GetLanguageProperty(SyntaxLanguage.VB);
if (result.FullName != fullnameForVB)
{
result.FullNameForVB = fullnameForVB;
}
var modifierCSharp = model.Modifiers.GetLanguageProperty(SyntaxLanguage.CSharp);
if (modifierCSharp?.Count > 0)
{
result.Modifiers["csharp"] = modifierCSharp;
}
var modifierForVB = model.Modifiers.GetLanguageProperty(SyntaxLanguage.VB);
if (modifierForVB?.Count > 0)
{
result.Modifiers["vb"] = modifierForVB;
}
return(result);
}
public virtual void GenerateField(IFieldSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
private static void GetAllItemByCommentId(Dictionary <string, MetadataItem> items, MetadataItem item)
{
if (!items.ContainsKey(item.CommentId))
{
items.Add(item.CommentId, item);
}
foreach (var metadataItem in item.Items ?? Enumerable.Empty <MetadataItem>())
{
GetAllItemByCommentId(items, metadataItem);
}
}
public virtual void GenerateEvent(IEventSymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
}
private static void PatchViewModel(MetadataItem item, string comment)
{
var context = new TripleSlashCommentParserContext
{
AddReferenceDelegate = (s, e) => { }
};
var commentModel = TripleSlashCommentModel.CreateModel(comment, SyntaxLanguage.CSharp, context);
var summary = commentModel.Summary;
if (!string.IsNullOrEmpty(summary))
{
item.Summary = summary;
}
var remarks = commentModel.Remarks;
if (!string.IsNullOrEmpty(remarks))
{
item.Remarks = remarks;
}
var exceptions = commentModel.Exceptions;
if (exceptions != null && exceptions.Count > 0)
{
item.Exceptions = exceptions;
}
var sees = commentModel.Sees;
if (sees != null && sees.Count > 0)
{
item.Sees = sees;
}
var seeAlsos = commentModel.SeeAlsos;
if (seeAlsos != null && seeAlsos.Count > 0)
{
item.SeeAlsos = seeAlsos;
}
var examples = commentModel.Examples;
if (examples != null && examples.Count > 0)
{
item.Examples = examples;
}
if (item.Syntax != null)
{
if (item.Syntax.Parameters != null)
{
foreach (var p in item.Syntax.Parameters)
{
var description = commentModel.GetParameter(p.Name);
if (!string.IsNullOrEmpty(description))
{
p.Description = description;
}
}
}
if (item.Syntax.TypeParameters != null)
{
foreach (var p in item.Syntax.TypeParameters)
{
var description = commentModel.GetTypeParameter(p.Name);
if (!string.IsNullOrEmpty(description))
{
p.Description = description;
}
}
}
if (item.Syntax.Return != null)
{
var returns = commentModel.Returns;
if (!string.IsNullOrEmpty(returns))
{
item.Syntax.Return.Description = returns;
}
}
}
// todo more.
}
public override void GenerateProperty(IPropertySymbol symbol, MetadataItem item, SymbolVisitorAdapter adapter)
{
base.GenerateProperty(symbol, item, adapter);
var modifiers = new List<string>();
var propertyVisiblity = GetVisiblity(symbol.DeclaredAccessibility);
if (symbol.ContainingType.TypeKind != TypeKind.Interface)
{
if (propertyVisiblity != null)
{
modifiers.Add(propertyVisiblity);
}
if (symbol.IsStatic)
{
modifiers.Add("Shared");
}
if (symbol.IsAbstract)
{
modifiers.Add("MustOverride");
}
if (symbol.IsOverride)
{
modifiers.Add("Overrides");
}
if (symbol.IsVirtual && symbol.IsSealed)
{
}
else if (symbol.IsVirtual)
{
modifiers.Add("Overridable");
}
else if (symbol.IsSealed)
{
modifiers.Add("NotOverridable");
}
}
bool hasGetMethod = symbol.GetMethod != null;
bool hasSetMethod = symbol.SetMethod != null;
var getMethodVisiblity = hasGetMethod ? GetVisiblity(symbol.GetMethod.DeclaredAccessibility) : null;
var setMethodVisiblity = hasSetMethod ? GetVisiblity(symbol.SetMethod.DeclaredAccessibility) : null;
if (hasGetMethod ^ hasSetMethod)
{
if (hasGetMethod)
{
modifiers.Add("ReadOnly");
}
else
{
modifiers.Add("WriteOnly");
}
}
else if (propertyVisiblity != null &&
(getMethodVisiblity == null ^ setMethodVisiblity == null))
{
if (setMethodVisiblity == null)
{
modifiers.Add("ReadOnly");
}
if (getMethodVisiblity == null)
{
modifiers.Add("WriteOnly");
}
}
else if (getMethodVisiblity != propertyVisiblity ||
setMethodVisiblity != propertyVisiblity)
{
if (getMethodVisiblity != propertyVisiblity)
{
modifiers.Add($"{getMethodVisiblity} Get");
}
else
{
modifiers.Add("Get");
}
if (setMethodVisiblity != propertyVisiblity)
{
modifiers.Add($"{setMethodVisiblity} Set");
}
else
{
modifiers.Add("Set");
}
}
item.Modifiers[SyntaxLanguage.VB] = modifiers;
}
