public static TypeMemberLink ConvertTypeMemberLink(Models.Type t, Member m)
{
if (m == null)
{
return(null);
}
var monikers = m.Monikers;
VersionedString inheritanceInfo = null;
if (t?.InheritedMembers != null &&
t.InheritedMembers.TryGetValue(m.Uid, out inheritanceInfo) &&
inheritanceInfo.Monikers != null)
{
monikers = inheritanceInfo.Monikers;
}
if (monikers.Any())
{
return(new TypeMemberLink()
{
Uid = m.Uid,
InheritedFrom = inheritanceInfo != null ? m.Parent.Uid : null,
Monikers = monikers
});
}
return(null);
}
public IEnumerable <VersionedString> MonikerizeDerivedClasses(Models.Type t)
{
//not top level class like System.Object, has children
if (t.ItemType == ItemType.Interface &&
_store.ImplementationChildrenByUid.ContainsKey(t.Uid))
{
return(_store.ImplementationChildrenByUid[t.Uid]
.GroupBy(vs => vs.Value)
.Select(g => new VersionedString()
{
Value = g.Key,
Monikers = ConverterHelper.TrimMonikers(MergeMonikerHashSets(g.Select(gvs => gvs.Monikers).ToArray()), t.Monikers)
}));
}
else if (_store.InheritanceParentsByUid.ContainsKey(t.Uid) &&
_store.InheritanceParentsByUid[t.Uid]?.Count > 0 &&
_store.InheritanceChildrenByUid.ContainsKey(t.Uid))
{
return(_store.InheritanceChildrenByUid[t.Uid]
.GroupBy(vs => vs.Value)
.Select(g => new VersionedString()
{
Value = g.Key,
Monikers = ConverterHelper.TrimMonikers(MergeMonikerHashSets(g.Select(gvs => gvs.Monikers).ToArray()), t.Monikers)
}));
}
return(null);
}
private static ItemType InferTypeOfType(Models.Type t)
{
var signature = t.Signatures.Dict[ECMADevLangs.CSharp].FirstOrDefault()?.Value;
if (t.BaseTypes == null && signature.Contains(" interface "))
{
return(ItemType.Interface);
}
else if ((t.BaseTypes == null || t.BaseTypes.Any(bt => bt.Name == "System.Enum")) &&
signature.Contains(" enum "))
{
return(ItemType.Enum);
}
else if ((t.BaseTypes == null || t.BaseTypes.Any(bt => bt.Name == "System.Delegate")) &&
signature.Contains(" delegate "))
{
return(ItemType.Delegate);
}
else if ((t.BaseTypes == null || t.BaseTypes.Any(bt => bt.Name == "System.ValueType")) &&
signature.Contains(" struct "))
{
return(ItemType.Struct);
}
else if (signature.Contains(" class "))
{
return(ItemType.Class);
}
else
{
throw new Exception("Unable to identify the type of Type " + t.Name);
}
}
public static NamespaceTypeLink ConvertNamespaceTypeLink(Namespace ns, Models.Type t)
{
if (t == null)
{
return(null);
}
return(new NamespaceTypeLink()
{
Uid = t.Uid,
Monikers = t.Monikers
});
}
private Member LoadMemberGroup(Models.Type t, XElement mElement)
{
Member m = new Member
{
Parent = t,
Name = mElement.Attribute("MemberName").Value,
AssemblyInfo = mElement.Elements("AssemblyInfo")?.SelectMany(a => ParseAssemblyInfo(a)).ToList(),
Docs = LoadDocs(mElement.Element("Docs"), t.SourceFileLocalPath)
};
return(m);
}
private static TOCNodeYamlModel GenerateTocItemForType(Models.Type t)
{
var tToc = new TOCNodeYamlModel()
{
Uid = t.Uid,
Name = t.Name,
Items = GenerateTocItemsForMembers(t)
};
if (IsNeedAddMonikers(t.Parent.Monikers, t.Monikers))
{
tToc.Monikers = t.Monikers.ToArray();
}
return(tToc);
}
private static List <TOCNodeYamlModel> GenerateTocItemsForMembers(Models.Type t)
{
if (t.Members == null ||
t.Members.Count == 0 ||
t.ItemType == ItemType.Enum)
{
return(null);
}
var items = new List <TOCNodeYamlModel>();
foreach (var olGroup in t.Members.Where(m => m.Overload != null).GroupBy(m => m.Overload))
{
var ol = t.Overloads.FirstOrDefault(o => o.Uid == olGroup.Key);
var tocEntry = new TOCNodeYamlModel()
{
Uid = ol.Uid,
Name = ol.DisplayName
};
tocEntry.Type = ol.ItemType.ToString();
if ((ol.ItemType == ItemType.Method || ol.ItemType == ItemType.Property) && olGroup.First().IsEII)
{
tocEntry.IsEII = true;
}
if (IsNeedAddMonikers(t.Monikers, ol.Monikers))
{
tocEntry.Monikers = ol.Monikers.ToArray();
}
items.Add(tocEntry);
}
foreach (var m in t.Members.Where(m => m.Overload == null))
{
var tocEntry = new TOCNodeYamlModel()
{
Uid = m.Uid,
Name = m.DisplayName
};
tocEntry.Type = m.ItemType.ToString();
if (IsNeedAddMonikers(t.Monikers, m.Monikers))
{
tocEntry.Monikers = m.Monikers.ToArray();
}
items.Add(tocEntry);
}
return(items);
}
public EnumSDPModel FormatEnum(Type enumTypeItem, HashSet <string> memberTouchCache)
{
var sdpEnum = InitWithBasicProperties <EnumSDPModel>(enumTypeItem);
if (_withVersioning)
{
sdpEnum.InheritancesWithMoniker = ConverterHelper.TrimMonikers(
enumTypeItem.InheritanceChains?.Select(
chain => new VersionedCollection <string>(
chain.Monikers,
chain.Values.Select(uid => UidToTypeMDString(uid, _store)).ToList()
)).ToList(),
enumTypeItem.Monikers);
}
else
{
sdpEnum.Inheritances = enumTypeItem.InheritanceChains?.LastOrDefault().Values.Select(uid => UidToTypeMDString(uid, _store)).ToList();
}
sdpEnum.IsFlags = enumTypeItem.Attributes != null &&
enumTypeItem.Attributes.Any(attr => attr.Declaration == "System.Flags");
sdpEnum.Fields = enumTypeItem.Members.Select(fItem =>
{
var f = new EnumField()
{
Uid = fItem.Uid,
CommentId = fItem.CommentId,
Name = fItem.DisplayName,
NameWithType = enumTypeItem.Name + '.' + fItem.Name,
FullName = fItem.FullDisplayName,
Summary = fItem.Docs.Summary,
Monikers = fItem.Monikers
};
if (fItem.Metadata.TryGetValue(OPSMetadata.LiteralValue, out object val))
{
f.LiteralValue = val?.ToString();
}
f.LiteralValue = f.LiteralValue ?? "";
memberTouchCache.Add(f.Uid);
return(f);
}).ToList().NullIfEmpty();
return(sdpEnum);
}
public TypeMemberLink ExtensionMethodToTypeMemberLink(Models.Type t, VersionedString vs)
{
HashSet <string> monikers = vs.Monikers;
if (_store.MembersByUid.TryGetValue(vs.Value, out var m))
{
if (monikers == null)
{
monikers = m.Monikers;
}
else
{
monikers = monikers.Intersect(m.Monikers).ToHashSet();
}
}
if (monikers != null)
{
if (monikers.Count > t.Monikers.Count)
{
monikers = monikers.Intersect(t.Monikers).ToHashSet();
}
//don't move same monikers for now, for less diff
//if (monikers.SetEquals(t.Monikers))
//{
// monikers = null;
//}
}
if (monikers != null && monikers.Count == 0)
{
return(null);
}
return(new TypeMemberLink()
{
Uid = vs.Value,
Monikers = monikers
});
}
private Member LoadMember(Models.Type t, XElement mElement)
{
Member m = new Member();
m.Parent = t;
m.Name = mElement.Attribute("MemberName").Value;
m.ItemType = (ItemType)Enum.Parse(typeof(ItemType), mElement.Element("MemberType").Value);
if (m.Name.StartsWith("op_") && m.ItemType == ItemType.Method)
{
m.ItemType = ItemType.Operator;
}
var memberValue = mElement.Element("MemberValue")?.Value;
if (!string.IsNullOrEmpty(memberValue))
{
m.Metadata[OPSMetadata.LiteralValue] = memberValue;
}
m.Signatures = new VersionedSignatures(mElement.Elements("MemberSignature"), m.ItemType);
m.Modifiers = m.Signatures.CombinedModifiers;
m.DocId = m.Signatures.DocId;
m.AssemblyInfo = mElement.Elements("AssemblyInfo")?.SelectMany(a => ParseAssemblyInfo(a)).ToList();
//TypeParameters
var tpElement = mElement.Element("TypeParameters");
if (tpElement != null)
{
m.TypeParameters = ParameterBase.LoadVersionedParameters <TypeParameter>(tpElement.Elements("TypeParameter"));
}
//Parameters
var pElement = mElement.Element("Parameters");
if (pElement != null)
{
m.Parameters = ParameterBase.LoadVersionedParameters <Parameter>(pElement.Elements("Parameter"));
}
//Attributes
var attrs = mElement.Element("Attributes");
if (attrs != null)
{
m.Attributes = attrs.Elements("Attribute").Select(a => LoadAttribute(a)).ToList();
}
// Load monikerized return type data
var returnValueElement = mElement.Element("ReturnValue");
m.ReturnValueType = MonikerizeReturnValue(returnValueElement);
var implements = mElement.Element("Implements");
if (implements != null)
{
m.Implements = implements.Elements("InterfaceMember")?.Select(LoadMonikerizedValue).ToList();
}
//Docs
m.Docs = LoadDocs(mElement.Element("Docs"), t.SourceFileLocalPath);
LoadMetadata(m, mElement);
return(m);
}
private Models.Type LoadType(FileItem typeFile)
{
string xmlContent = _fileAccessor.ReadAllText(typeFile.RelativePath);
xmlContent = xmlContent.Replace("TextAntiAliasingQuality property.</summary>", "TextAntiAliasingQuality property.</summary>");
xmlContent = xmlContent.Replace("DefaultValue('�')</AttributeName>", "DefaultValue('\\0')</AttributeName>");
xmlContent = xmlContent.Replace("\0", "\\0");
XDocument tDoc = XDocument.Parse(xmlContent, LoadOptions.PreserveWhitespace);
XElement tRoot = tDoc.Root;
if (tRoot.Name.LocalName != "Type")
{
return(null);
}
Models.Type t = new Models.Type();
t.Name = tRoot.Attribute("Name").Value.Replace('+', '.');
t.FullName = tRoot.Attribute("FullName").Value.Replace('+', '.');
t.SourceFileLocalPath = typeFile.AbsolutePath;
//TypeSignature
t.Signatures = new VersionedSignatures(tRoot.Elements("TypeSignature"));
t.Modifiers = t.Signatures.CombinedModifiers;
t.DocId = t.Signatures.DocId;
//AssemblyInfo
t.AssemblyInfo = tRoot.Elements("AssemblyInfo")?.SelectMany(a => ParseAssemblyInfo(a)).ToList();
//TypeParameters
var tpElement = tRoot.Element("TypeParameters");
if (tpElement != null)
{
t.TypeParameters = ParameterBase.LoadVersionedParameters <TypeParameter>(tpElement.Elements("TypeParameter"));
}
//Parameters
var pElement = tRoot.Element("Parameters");
if (pElement != null)
{
t.Parameters = ParameterBase.LoadVersionedParameters <Parameter>(pElement.Elements("Parameter"));
}
var rvalElement = tRoot.Element("ReturnValue");
if (rvalElement != null)
{
t.ReturnValueType = MonikerizeReturnValue(rvalElement);
}
//BaseTypeName
t.BaseTypes = LoadBaseType(tRoot.Element("Base"));
//Interfaces
var interfacesElement = tRoot.Element("Interfaces");
if (interfacesElement != null)
{
t.Interfaces = interfacesElement.Elements("Interface")
.Select(i => new VersionedString(LoadFrameworkAlternate(i), i?.Element("InterfaceName")?.Value))
.ToList();
}
//Attributes
var attrs = tRoot.Element("Attributes");
if (attrs != null)
{
t.Attributes = attrs.Elements("Attribute").Select(a => LoadAttribute(a)).ToList();
}
//TypeForwardingChain
var forwardingChain = tRoot.Element("TypeForwardingChain");
if (forwardingChain != null)
{
var fwds = forwardingChain.Elements("TypeForwarding").Select(fwd => LoadTypeForwarding(fwd)).ToList();
t.TypeForwardingChain = new TypeForwardingChain(fwds);
}
//Members
var membersElement = tRoot.Element("Members");
if (membersElement != null)
{
t.Members = membersElement.Elements("Member")?.Select(m => LoadMember(t, m)).ToList();
t.Members.Sort((m1, m2) =>
{
if (m1.IsEII == m2.IsEII)
{
return(string.Compare(m1.Name, m2.Name));
}
else
{
return(m1.IsEII ? 1 : -1); //non-EII first, EII later
}
});
if (t.Members != null)
{
foreach (var m in t.Members)
{
m.SourceFileLocalPath = typeFile.AbsolutePath;
}
}
t.Overloads = membersElement.Elements("MemberGroup")?.Select(m => LoadMemberGroup(t, m)).ToList();
if (t.Overloads != null)
{
var distinctList = new List <Member>();
foreach (var og in t.Overloads.GroupBy(o => o.Name))
{
if (og.Count() > 1)
{
OPSLogger.LogUserWarning(LogCode.ECMA2Yaml_MemberGroup_Duplicated, typeFile.AbsolutePath, og.Key);
}
og.First().SourceFileLocalPath = typeFile.AbsolutePath;
distinctList.Add(og.First());
}
t.Overloads = distinctList;
}
}
//Docs
t.Docs = LoadDocs(tRoot.Element("Docs"), typeFile.AbsolutePath);
//MemberType
t.ItemType = InferTypeOfType(t);
if (t.ItemType == ItemType.Enum && t.Members?.Count > 0)
{
foreach (var m in t.Members)
{
if (!string.IsNullOrEmpty(m.Docs.Remarks))
{
OPSLogger.LogUserSuggestion(LogCode.ECMA2Yaml_Enum_NoRemarks, typeFile.AbsolutePath);
}
}
}
// Metadata
LoadMetadata(t, tRoot);
return(t);
}
