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); }