public static void Generate(ItemSDPModelBase model, ReflectionItem item)
{
var apiNames = GetApiNames(item).ToList();
var assemblies = item.AssemblyInfo?.Select(asm => asm.Name).Distinct().ToList();
if (apiNames.Count > 0)
{
if (!model.Metadata.ContainsKey(APISCAN_APINAME))
{
model.Metadata[APISCAN_APINAME] = apiNames;
}
if (!model.Metadata.ContainsKey(APISCAN_APILOCATION))
{
model.Metadata[APISCAN_APILOCATION] = assemblies.Select(a => a + ".dll").ToList();
}
if (!model.Metadata.ContainsKey(APISCAN_TOPICTYPE))
{
model.Metadata[APISCAN_TOPICTYPE] = new List <string> {
"apiref"
};
}
if (!model.Metadata.ContainsKey(APISCAN_APITYPE))
{
model.Metadata[APISCAN_APITYPE] = new List <string> {
"Assembly"
};
}
}
}
private static ReportItem ValidateItem(ReflectionItem item, string branch = null)
{
var urlPath = item.Uid.Replace('`', '-').Replace('#', '-').Replace('{', '-').Replace('}', '-').Replace('[', '-').Replace(']', '-');
if (urlPath.Contains('('))
{
urlPath = urlPath.Substring(0, urlPath.IndexOf('('));
}
if (item.ItemType == ItemType.Field && item.Parent?.ItemType == ItemType.Enum)
{
urlPath = urlPath.Substring(0, urlPath.LastIndexOf('.'));
}
// fix bug 84377(https://ceapex.visualstudio.com/web/wi.aspx?pcguid=7d644393-99ad-41c8-ac53-7fa79294c720&id=84377)
if (item.ItemType == ItemType.Method)
{
urlPath = System.Text.RegularExpressions.Regex.Replace(urlPath, @"--\d{1,}", "");
}
var url = "";
if (branch == null || branch == "live")
{
url = $"https://docs.microsoft.com/en-us/dotnet/api/{urlPath}";
}
else
{
url = $"https://review.docs.microsoft.com/en-us/dotnet/api/{urlPath}?branch={branch}";
}
ReportItem report = new ReportItem()
{
Uid = item.Uid,
Url = url,
DocId = item.DocId,
ItemType = item.ItemType.ToString(),
Name = item.Name,
Results = _validator.ValidateItem(item),
SourceFilePath = item.Metadata.ContainsKey(OPSMetadata.RefSkeletionUrl) ? item.Metadata[OPSMetadata.RefSkeletionUrl] as string : item.SourceFileLocalPath,
Monikers = item.Monikers
};
switch (item)
{
case ECMA2Yaml.Models.Namespace ns:
report.Namespace = ns.Name;
report.Type = "";
break;
case ECMA2Yaml.Models.Type t:
report.Namespace = t.Parent?.Name;
report.Type = t.Name;
break;
case ECMA2Yaml.Models.Member m:
report.Namespace = m.Parent?.Parent?.Name;
report.Type = m.Parent?.Name;
break;
}
return(report);
}
private static IEnumerable <string> GenerateMemberApiNames(ReflectionItem item, params Separator[] separators)
{
var name = item.Name;
var prefix = "";
var dotIndex = name.LastIndexOf('.');
if (dotIndex > 0)
{
prefix = "." + name.Substring(0, dotIndex);
name = name.Substring(dotIndex + 1);
}
if (name.StartsWith("op_"))
{
name = name.Substring("op_".Length);
}
// methods with generics do not add any generics information
// (neither type parameters in angled brackets nor `[type parameter count])
if (name[name.Length - 1] == '>')
{
var index = name.LastIndexOf('<');
if (index != -1)
{
name = name.Remove(index);
}
}
foreach (var separator in separators)
{
if (separator.Condition(item))
{
yield return($"{item.Parent.Uid}{prefix}{separator}{name}");
}
}
}
public static void AreSame(ReflectionItem expected, ReflectionItem actual)
{
switch (expected.ItemType)
{
case ReflectionItemType.Property:
{
ReflectionProperty expectedProperty = (ReflectionProperty)expected;
ReflectionProperty actualProperty = (ReflectionProperty)actual;
ReflectionAssert.AreSame(expectedProperty.UnderlyingGetMethod, actualProperty.UnderlyingGetMethod);
ReflectionAssert.AreSame(expectedProperty.UnderlyingSetMethod, actualProperty.UnderlyingSetMethod);
return;
}
case ReflectionItemType.Parameter:
{
ReflectionParameter expectedParameter = (ReflectionParameter)expected;
ReflectionParameter actualParameter = (ReflectionParameter)actual;
ReflectionAssert.AreSame(expectedParameter.UnderlyingParameter, actualParameter.UnderlyingParameter);
return;
}
default:
{
ReflectionMember expectedMember = (ReflectionMember)expected;
ReflectionMember actualMember = (ReflectionMember)actual;
ReflectionAssert.AreSame(expectedMember.UnderlyingMember, actualMember.UnderlyingMember);
return;
}
}
}
private void GenerateRequiredMetadata(ItemSDPModelBase model, ReflectionItem item, List <ReflectionItem> childrenItems = null)
{
MergeWhiteListedMetadata(model, item);
if (item.ItemType != ItemType.Namespace)
{
ApiScanGenerator.Generate(model, item);
if (_store.UWPMode)
{
model.Metadata?.Remove(ApiScanGenerator.APISCAN_APILOCATION);
}
}
F1KeywordsGenerator.Generate(model, item, childrenItems);
HelpViewerKeywordsGenerator.Generate(model, item, childrenItems);
// Per V3 requirement, we need to put page level monikers in metadata node.
// To make it compatible with V2 and existing template code, we choose to duplicate this meta in both root level and metadata node
if (model is OverloadSDPModel ||
model is TypeSDPModel ||
model is NamespaceSDPModel ||
model is EnumSDPModel ||
model is DelegateSDPModel)
{
model.Metadata[OPSMetadata.Monikers] = model.Monikers;
}
}
private void LoadMetadata(ReflectionItem item, XElement rootElement)
{
var metadataElement = rootElement.Element("Metadata");
if (metadataElement != null)
{
item.ExtendedMetadata = new Dictionary <string, object>();
foreach (var g in metadataElement.Elements("Meta")
?.ToLookup(x => x.Attribute("Name").Value, x => x.Attribute("Value").Value))
{
if (UWPMetadata.Values.TryGetValue(g.Key, out var datatype))
{
switch (datatype)
{
case MetadataDataType.String:
item.Metadata.Add(g.Key, g.First());
break;
case MetadataDataType.StringArray:
item.Metadata.Add(g.Key, g.ToArray());
break;
}
}
else
{
item.ExtendedMetadata.Add(g.Key, g.Count() == 1 ? (object)g.First() : (object)g.ToArray());
}
}
}
}
public static IEnumerable <VersionedString> MonikerizeAssemblyStrings(ReflectionItem item)
{
if (item.VersionedAssemblyInfo == null)
{
//legacy xml, fallback to asseblies without versions
return(item.AssemblyInfo?.Select(asm => new VersionedString()
{
Value = asm.Name + ".dll"
}).ToList().NullIfEmpty());
}
var monikerAssembliesPairs = item.VersionedAssemblyInfo.ValuesPerMoniker
.Select(pair => (
moniker: pair.Key,
asmStr: string.Join(", ", pair.Value.OrderBy(asm => asm.Name).Select(asm => asm.Name + ".dll"))
))
.ToList();
var versionedList = monikerAssembliesPairs
.GroupBy(p => p.asmStr)
.Select(g => new VersionedString()
{
Value = g.Key, Monikers = g.Select(p => p.moniker).ToHashSet()
})
.ToList();
if (versionedList.Count == 1)
{
versionedList.First().Monikers = null;
}
return(versionedList.NullIfEmpty());
}
public static IEnumerable <VersionedString> MonikerizePackageStrings(ReflectionItem item, PackageInformationMapping pkgInfoMapping)
{
if (item.VersionedAssemblyInfo == null)
{
return(null);
}
var monikerPackagePairs = item.VersionedAssemblyInfo.ValuesPerMoniker
.Select(pair => (
moniker: pair.Key,
pkgStr: string.Join(", ", pair.Value.Select(asm => pkgInfoMapping.TryGetPackageDisplayString(pair.Key, asm.Name))
.Where(str => str != null)
.Distinct()
.OrderBy(str => str))
))
.Where(pair => pair.pkgStr != "")
.ToList();
var versionedList = monikerPackagePairs
.GroupBy(p => p.pkgStr)
.Select(g => new VersionedString()
{
Value = g.Key, Monikers = g.Select(p => p.moniker).ToHashSet()
})
.ToList();
if (versionedList.Count == 1)
{
versionedList.First().Monikers = null;
}
return(versionedList.NullIfEmpty());
}
private static IEnumerable <string> GetApiNames(ReflectionItem item)
{
if (ApiNameMapper.TryGetValue(item.ItemType, out Func <ReflectionItem, IEnumerable <string> > func))
{
return(func(item));
}
return(Enumerable.Empty <string>());
}
public Dictionary <FieldType, ValidationResult> ValidateItem(ReflectionItem item)
{
return(new Dictionary <FieldType, ValidationResult>()
{
{ FieldType.Summary, ValidateSummary(item) },
{ FieldType.ReturnValue, ValidateReturnValue(item) },
{ FieldType.Parameters, ValidateParameters(item) },
{ FieldType.TypeParameters, ValidateTypeParameters(item) }
});
}
internal static void MemberMarkedWithMultipleImportAndImportMany(ReflectionItem item)
{
ArgumentNullException.ThrowIfNull(item);
if (CompositionTraceSource.CanWriteError)
{
CompositionTraceSource.WriteError(CompositionTraceId.Discovery_MemberMarkedWithMultipleImportAndImportMany,
SR.CompositionTrace_Discovery_MemberMarkedWithMultipleImportAndImportMany,
item.GetDisplayName());
}
}
internal static void MemberMarkedWithMultipleImportAndImportMany(ReflectionItem item)
{
Assumes.NotNull(item);
if (CompositionTraceSource.CanWriteError)
{
CompositionTraceSource.WriteError(CompositionTraceId.Discovery_MemberMarkedWithMultipleImportAndImportMany,
Strings.CompositionTrace_Discovery_MemberMarkedWithMultipleImportAndImportMany,
item.GetDisplayName());
}
}
private static IEnumerable <string> GetTypeApiNamesCore(ReflectionItem item, params Separator[] separators)
{
string type = item.Uid;
foreach (var separator in separators)
{
if (separator.Condition(item))
{
yield return($"{type}{separator}");
}
}
}
public static object GetValue(object master, params string[] args)
{//ReflectionSystem.GetValue("SkillDatabase", "Instance", "SkillList[0]", "skillID");
string display = "Reflection trying to get value: ";
foreach (string str in args)
{
display += str + ",";
}
Debug.Log(display);
//Trying to know if the SkillDatabase is instance var or static class
object currentMaster = master;//static class don't have master
Type currentMasterType = master.GetType();
ReflectionItem reflectionItem = new ReflectionItem(currentMaster, args[0]);
if (reflectionItem.ReflectionItemType == ReflectionItemType.CLASS)
{ //static class
currentMaster = null; //Don't have master for static class
currentMasterType = reflectionItem.GetStaticClass();
}
else
{//instance variable
currentMaster = reflectionItem.GetValue();
}
for (int i = 1; i < args.Length; i++)
{
string target = args[i];
if (currentMaster == null)
{//static class
reflectionItem = new ReflectionItem(currentMasterType, target);
}
else
{//instance variable
reflectionItem = new ReflectionItem(currentMaster, target);
}
if (reflectionItem.ReflectionItemType == ReflectionItemType.CLASS)
{ //static class
currentMaster = null; //Don't have master for static class
currentMasterType = reflectionItem.GetStaticClass();
}
else
{//instance variable
currentMaster = reflectionItem.GetValue();
}
}
//if (currentMaster == null) return (object)currentMasterType;
return(currentMaster);
}
private static IEnumerable <string> GetEnumApiNames(ReflectionItem item)
{
List <string> names = new List <string>();
names.Add(item.Uid);
var t = item as Models.Type;
foreach (var f in t.Members)
{
names.Add(f.Uid);
}
return(names);
}
private Models.SDP.ThreadSafety ConvertThreadSafety(ReflectionItem item)
{
if (item.Docs.ThreadSafetyInfo != null)
{
return(new Models.SDP.ThreadSafety()
{
CustomizedContent = item.Docs.ThreadSafetyInfo.CustomContent,
IsSupported = item.Docs.ThreadSafetyInfo.Supported,
MemberScope = item.Docs.ThreadSafetyInfo.MemberScope
});
}
return(null);
}
private static void DisplayDebugWarnings(ImportCardinality cardinality, ReflectionItem item, ImportType importType)
{
if ((importType.ElementType == ExportType) || (importType.Type == ExportType))
{
System.Diagnostics.Debug.WriteLine(string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} : Imports of type Export are no longer supported", item.GetDisplayName()));
}
// Output a debug warning if someone is using ImportAttribute where it looks like they might want to use ImportMany
if (cardinality != ImportCardinality.ZeroOrMore && CollectionServices.GetEnumerableElementType(importType.Type) != null)
{
System.Diagnostics.Debug.WriteLine("May want to use ImportMany on " + item.GetDisplayName());
}
}
private static IEnumerable <string> GetHelpViewerKeywordsCore(ReflectionItem item)
{
switch (item.ItemType)
{
case ItemType.Namespace:
yield return($"{item.Name} {ConverterHelper.ItemTypeNameMapping[item.ItemType]} {DotNetProductSuffix}");
break;
case ItemType.Class:
case ItemType.Struct:
case ItemType.Enum:
case ItemType.Interface:
case ItemType.Delegate:
var t = item as Models.Type;
yield return($"{t.FullName} {ConverterHelper.ItemTypeNameMapping[item.ItemType]} {DotNetProductSuffix}");
break;
case ItemType.Constructor:
var c = item as Member;
yield return($"{c.DisplayName} {ConverterHelper.ItemTypeNameMapping[c.Parent.ItemType]} {DotNetProductSuffix}, constructors");
break;
case ItemType.Method:
case ItemType.Property:
case ItemType.Field:
case ItemType.Event:
case ItemType.Operator:
var m = item as Member;
var itemTypeStr = ConverterHelper.ItemTypeNameMapping[item.ItemType];
if (m.IsEII)
{
yield return($"{m.DisplayName} explicitly implemented {itemTypeStr} {DotNetProductSuffix}");
}
else if (!(item.Parent.ItemType == ItemType.Enum))
{
itemTypeStr = m.IsExtensionMethod ? $"extension method" : itemTypeStr;
yield return($"{m.Parent.Name}.{m.DisplayName} {itemTypeStr} {DotNetProductSuffix}");
yield return($"{m.DisplayName} {itemTypeStr} {DotNetProductSuffix}, {ConverterHelper.ItemTypeNameMapping[m.Parent.ItemType]} {m.Parent.Name}");
}
break;
default:
break;
}
}
public static void Generate(ItemSDPModelBase model, ReflectionItem item, List <ReflectionItem> childrenItems)
{
if (!model.Metadata.ContainsKey(OPSMetadata.F1Keywords))
{
var keywords = GetF1Keywords(item).ToList();
if (childrenItems != null)
{
foreach (var child in childrenItems)
{
keywords.AddRange(GetF1Keywords(child));
}
}
model.Metadata[OPSMetadata.F1Keywords] = keywords.Distinct().ToList();
}
}
private IEnumerable <TypeParameterSDPModel> ConvertTypeParameters(ReflectionItem item)
{
if (item.TypeParameters?.Count > 0)
{
return(item.TypeParameters.Select(tp =>
new TypeParameterSDPModel()
{
Description = tp.Description,
Name = tp.Name,
IsContravariant = tp.IsContravariant,
IsCovariant = tp.IsCovariant
}).ToList());
}
return(null);
}
private static IAttributedImport GetAttributedImport(ReflectionItem item, ICustomAttributeProvider attributeProvider)
{
IAttributedImport[] imports = attributeProvider.GetAttributes <IAttributedImport>(false);
// For constructor parameters they may not have an ImportAttribute
if (imports.Length == 0)
{
return(new ImportAttribute());
}
if (imports.Length > 1)
{
CompositionTrace.MemberMarkedWithMultipleImportAndImportMany(item);
}
// Regardless of how many imports, always return the first one
return(imports[0]);
}
public static SortedList <string, string> BuildSignatures(ReflectionItem item, bool uwpMode = false)
{
var contents = new SortedList <string, string>();
if (item.Signatures?.Dict != null)
{
foreach (var sigPair in item.Signatures.Dict)
{
if (Models.ECMADevLangs.OPSMapping.ContainsKey(sigPair.Key))
{
var lang = Models.ECMADevLangs.OPSMapping[sigPair.Key];
var val = sigPair.Value.LastOrDefault()?.Value;
switch (sigPair.Key)
{
case ECMADevLangs.CSharp:
var sig = uwpMode ? UWPCSharpSignatureTransform(val) : val;
var contentBuilder = new StringBuilder();
if (item.Attributes?.Count > 0)
{
foreach (var att in item.Attributes.Where(attr => attr.Visible))
{
contentBuilder.AppendFormat("[{0}]\n", att.Declaration);
}
}
contentBuilder.Append(sig);
contents[lang] = contentBuilder.ToString();
break;
case ECMADevLangs.CPP_CLI:
case ECMADevLangs.CPP_CX:
case ECMADevLangs.CPP_WINRT:
contents[lang] = uwpMode ? UWPCPPSignatureTransform(val) : val;
break;
default:
contents[lang] = val;
break;
}
}
}
}
return(contents);
}
private static IAttributedImport GetAttributedImport(ReflectionItem item, ICustomAttributeProvider attributeProvider)
{
IAttributedImport[] imports = attributeProvider.GetAttributes <IAttributedImport>(false);
// For constructor parameters they may not have an ImportAttribute
if (imports.Length == 0)
{
return(new ImportAttribute());
}
if (imports.Length == 1)
{
return(imports[0]);
}
// DiscoveryError (Dev10:602872): This should go through the discovery error reporting when
// we add a way to report discovery errors properly.
throw ExceptionBuilder.CreateDiscoveryException(Strings.Discovery_MultipleImportAttributes, item.GetDisplayName());
}
private void MergeWhiteListedMetadata(ItemSDPModelBase model, ReflectionItem item)
{
if (item?.Metadata != null)
{
foreach (var pair in item.Metadata)
{
if (MetadataMapping.TryGetValue(pair.Key, out string newKey))
{
model.Metadata[newKey] = pair.Value;
}
}
}
if (item?.ExtendedMetadata?.Count > 0)
{
foreach (var pair in item.ExtendedMetadata)
{
model.Metadata[pair.Key] = pair.Value;
}
}
}
public ValidationResult ValidateParameters(ReflectionItem item)
{
if (item.Parameters == null || item.Parameters.Count == 0)
{
return(ValidationResult.NA);
}
foreach (var param in item.Parameters)
{
if (!item.Docs.Parameters.ContainsKey(param.Name))
{
return(ValidationResult.Missing);
}
var paramResult = ValidateSimpleString(item.Docs.Parameters[param.Name], ParametersLengthRequirement);
if (paramResult != ValidationResult.Present)
{
return(paramResult);
}
}
return(ValidationResult.Present);
}
public static void Generate(
ItemSDPModelBase model,
ReflectionItem item,
List <ReflectionItem> childrenItems)
{
if (model != null && !model.Metadata.ContainsKey(OPSMetadata.HelpViewerKeywords))
{
var keywords = item.ItemType == ItemType.Property // skip property overload
? new List <string>()
: GetHelpViewerKeywordsCore(item).ToList();
if (childrenItems != null)
{
foreach (var child in childrenItems)
{
keywords.AddRange(GetHelpViewerKeywordsCore(child));
}
}
if (keywords.Count > 0)
{
model.Metadata[OPSMetadata.HelpViewerKeywords] = keywords.Distinct().ToList();
}
}
}
public ValidationResult ValidateReturnValue(ReflectionItem item)
{
if (item.ReturnValueType == null ||
item.ItemType == ItemType.Event ||
item.ReturnValueType.VersionedTypes.Any(r =>
string.IsNullOrWhiteSpace(r.Value) ||
r.Value == "System.Void"))
{
return(ValidationResult.NA);
}
var result = ValidateSimpleString(item.Docs.Returns, ReturnsLengthRequirement);
// fix bug 84378(https://ceapex.visualstudio.com/web/wi.aspx?pcguid=7d644393-99ad-41c8-ac53-7fa79294c720&id=84378)
if ((result == ValidationResult.Missing) && (item.ItemType == ItemType.Field || item.ItemType == ItemType.Property))
{
return(ValidationResult.NA);
}
else
{
return(result);
}
}
//
// Import definition creation helpers
//
private static AttributedImportDefinitionCreationInfo GetImportDefinitionCreationInfo(ReflectionItem item, ICustomAttributeProvider attributeProvider)
{
Assumes.NotNull(item, attributeProvider);
AttributedImportDefinitionCreationInfo importCreationInfo = new AttributedImportDefinitionCreationInfo();
IAttributedImport attributedImport = AttributedModelDiscovery.GetAttributedImport(item, attributeProvider);
ImportType importType = new ImportType(item.ReturnType, attributedImport.Cardinality);
DisplayDebugWarnings(attributedImport.Cardinality, item, importType);
importCreationInfo.RequiredMetadata = importType.IsLazy ?
CompositionServices.GetRequiredMetadata(importType.LazyType.MetadataViewType) :
Enumerable.Empty <string>();
importCreationInfo.Cardinality = attributedImport.Cardinality;
importCreationInfo.ContractName = attributedImport.GetContractNameFromImport(importType);
importCreationInfo.RequiredTypeIdentity = attributedImport.GetTypeIdentityFromImport(importType);
importCreationInfo.IsRecomposable = (item.ItemType == ReflectionItemType.Parameter) ? false : attributedImport.AllowRecomposition;
importCreationInfo.RequiredCreationPolicy = attributedImport.RequiredCreationPolicy;
return(importCreationInfo);
}
public ValidationResult ValidateSummary(ReflectionItem item)
{
return(ValidateSimpleString(item.Docs.Summary, SummaryLengthRequirement));
}
private T InitWithBasicProperties <T>(ReflectionItem item) where T : ItemSDPModelBase, new()
{
T rval = new T
{
Uid = item.Uid,
CommentId = item.CommentId,
Name = item.Name,
DevLangs = item.Signatures?.DevLangs ?? defaultLangList,
SeeAlso = BuildSeeAlsoList(item.Docs, _store),
Summary = item.Docs.Summary,
Remarks = item.Docs.Remarks,
Examples = item.Docs.Examples,
Monikers = item.Monikers,
Source = (_store.UWPMode || _store.DemoMode) ?item.SourceDetail.ToSDPSourceDetail() : null
};
if (_withVersioning)
{
rval.AssembliesWithMoniker = _store.UWPMode ? null : MonikerizeAssemblyStrings(item);
rval.PackagesWithMoniker = _store.UWPMode ? null : MonikerizePackageStrings(item, _store.PkgInfoMapping);
rval.AttributesWithMoniker = item.Attributes?.Where(att => att.Visible)
.Select(att => new VersionedString()
{
Value = att.TypeFullName, Monikers = att.Monikers?.ToHashSet()
})
.DistinctVersionedString()
.ToList().NullIfEmpty();
rval.AttributeMonikers = ConverterHelper.ConsolidateVersionedValues(rval.AttributesWithMoniker, item.Monikers);
rval.SyntaxWithMoniker = ConverterHelper.BuildVersionedSignatures(item, uwpMode: _store.UWPMode)?.NullIfEmpty();
}
else
{
rval.Assemblies = _store.UWPMode ? null : item.AssemblyInfo?.Select(asm => asm.Name).Distinct().ToList();
rval.Attributes = item.Attributes?.Where(att => att.Visible).Select(att => att.TypeFullName)
.ToList().NullIfEmpty();
var rawSignatures = ConverterHelper.BuildSignatures(item, uwpMode: _store.UWPMode);
rval.Syntax = rawSignatures?.Select(sig => new SignatureModel()
{
Lang = sig.Key, Value = sig.Value
}).ToList();
}
switch (item)
{
case Member m:
rval.Namespace = string.IsNullOrEmpty(m.Parent.Parent.Name) ? null : m.Parent.Parent.Name;
rval.FullName = m.FullDisplayName;
rval.Name = m.DisplayName;
rval.NameWithType = m.Parent.Name + '.' + m.DisplayName;
break;
case ECMA2Yaml.Models.Type t:
rval.Namespace = string.IsNullOrEmpty(t.Parent.Name) ? null : t.Parent.Name;
rval.FullName = t.FullName;
rval.NameWithType = t.FullName;
var children = t.ItemType == ItemType.Enum
? t.Members.Cast <ReflectionItem>().ToList()
: null;
GenerateRequiredMetadata(rval, item, children);
break;
case Namespace n:
rval.Namespace = n.Name;
rval.FullName = n.Name;
GenerateRequiredMetadata(rval, item);
break;
}
if (item.Metadata.TryGetValue(OPSMetadata.InternalOnly, out object val))
{
rval.IsInternalOnly = (bool)val;
}
if (item.Metadata.TryGetValue(OPSMetadata.AdditionalNotes, out object notes))
{
rval.AdditionalNotes = (AdditionalNotes)notes;
}
if (item.Attributes != null)
{
rval.ObsoleteMessagesWithMoniker = item.Attributes
.Where(attr => attr.TypeFullName == "System.ObsoleteAttribute")
.Select(attr => new VersionedString()
{
Value = GenerateObsoleteNotification(attr.Declaration),
Monikers = attr.Monikers
})
.ToList().NullIfEmpty();
}
if (_store.UWPMode || _store.DemoMode)
{
GenerateUWPRequirements(rval, item);
}
return(rval);
}
