Merge pull request #622 from mono/develop

huangmin-ms · web-flow · commit 489be60c6a3f · 2022-03-24T10:36:37.000+08:00
bump mdoc to 5.8.8
diff --git a/mdoc/Consts.cs b/mdoc/Consts.cs
@@ -3,7 +3,7 @@ namespace Mono.Documentation
 {
     public static class Consts
     {
-        public static string MonoVersion = "5.8.7";
+        public static string MonoVersion = "5.8.8";
         public const string DocId = "DocId";
         public const string CppCli = "C++ CLI";
         public const string CppCx = "C++ CX";
@@ -49,5 +49,8 @@ public static class Consts
         public const string IsByRefLikeAttribute = "System.Runtime.CompilerServices.IsByRefLikeAttribute";
         public const string IsReadOnlyAttribute = "System.Runtime.CompilerServices.IsReadOnlyAttribute";
         public const string InAttribute = "System.Runtime.InteropServices.InAttribute";
+        public const string TupleElementNamesAttribute = "System.Runtime.CompilerServices.TupleElementNamesAttribute";
+        public const string IsExternalInit = "System.Runtime.CompilerServices.IsExternalInit";
+        public const string NativeIntegerAttribute = "System.Runtime.CompilerServices.NativeIntegerAttribute";
     }
 }
diff --git a/mdoc/Mono.Documentation/MDocUpdater.cs b/mdoc/Mono.Documentation/MDocUpdater.cs
@@ -3997,7 +3997,7 @@ public void MakeParameters (XmlElement root, MemberReference member, IList<Param
                     xelement.RemoveAttribute(Consts.Index);
                     xelement.SetAttribute(Consts.Index, i.ToString());
                     xelement.SetAttribute (Consts.FrameworkAlternate, fxaValue);
-                    
+                    MakeParamsAttributes(xelement, AttributeFormatter.PreProcessCustomAttributes(p.Definition.CustomAttributes), typeEntry, member);
                     continue;
                 }
                 else {
diff --git a/mdoc/Mono.Documentation/Updater/AttributeParserContext.cs b/mdoc/Mono.Documentation/Updater/AttributeParserContext.cs
@@ -3,23 +3,30 @@
 using Mono.Documentation.Util;
 using System;
 using System.Collections.ObjectModel;
+using System.Linq;
 
 namespace Mono.Documentation.Updater
 {
     public class AttributeParserContext : IAttributeParserContext
     {
         private int nullableAttributeIndex;
         private int dynamicAttributeIndex;
+        private int tupleNameAttributeIndex;
+        private int nativeIntegerAttributeIndex;
         private ICustomAttributeProvider provider;
         private ReadOnlyCollection<bool?> nullableAttributeFlags;
         private ReadOnlyCollection<bool> dynamicAttributeFlags;
+        private string[] tupleElementNames;
+        private bool[] nativeIntegerFlags;
 
         private AttributeParserContext(ICustomAttributeProvider provider)
         {
             this.provider = provider;
 
             ReadDynamicAttribute();
             ReadNullableAttribute();
+            ReadTupleElementNames();
+            ReadNativeIntegerAttribute();
         }
 
         private bool ExistsNullableAttribute
@@ -73,6 +80,16 @@ public bool IsNullable()
             return false;
         }
 
+        public string GetTupleElementName()
+        {
+            return (tupleElementNames == null || tupleNameAttributeIndex >= tupleElementNames.Length) ? null : tupleElementNames[tupleNameAttributeIndex++];
+        }
+
+        public bool IsNativeInteger()
+        {
+            return nativeIntegerFlags != null && nativeIntegerAttributeIndex < nativeIntegerFlags.Length && nativeIntegerFlags[nativeIntegerAttributeIndex++];
+        }
+
         private void ReadDynamicAttribute()
         {
             DynamicTypeProvider dynamicTypeProvider = new DynamicTypeProvider(provider);
@@ -88,5 +105,31 @@ private void ReadNullableAttribute()
             NullableReferenceTypeProvider nullableReferenceTypeProvider = new NullableReferenceTypeProvider(provider);
             nullableAttributeFlags = new ReadOnlyCollection<bool?>(nullableReferenceTypeProvider.GetNullableReferenceTypeFlags());
         }
+
+        private void ReadTupleElementNames()
+        {
+            tupleElementNames = ReadCustomAttributeValue<string>(Consts.TupleElementNamesAttribute);
+        }
+
+        private void ReadNativeIntegerAttribute()
+        {
+            nativeIntegerFlags = ReadCustomAttributeValue<bool>(
+                Consts.NativeIntegerAttribute,
+                () => new bool[] { true });
+        }
+
+        private T[] ReadCustomAttributeValue<T>(string attributeName, Func<T[]> init = null)
+        {
+            if (provider == null || !provider.HasCustomAttributes) return null;
+
+            var customAttribute = provider.CustomAttributes.Where(attr => attr.AttributeType.FullName == attributeName).FirstOrDefault();
+
+            if (customAttribute == null) return null;
+
+            if (!customAttribute.HasConstructorArguments) return init?.Invoke();
+
+            var constructorArgs = customAttribute.ConstructorArguments[0].Value as CustomAttributeArgument[];
+            return constructorArgs?.Select(arg => (T)arg.Value).ToArray();
+        }
     }
 }
diff --git a/mdoc/Mono.Documentation/Updater/EmptyAttributeParserContext.cs b/mdoc/Mono.Documentation/Updater/EmptyAttributeParserContext.cs
@@ -26,5 +26,15 @@ public bool IsNullable()
         {
             return false;
         }
+
+        public string GetTupleElementName()
+        {
+            return null;
+        }
+
+        public bool IsNativeInteger()
+        {
+            return false;
+        }
     }
 }
diff --git a/mdoc/Mono.Documentation/Updater/Formatters/AttributeFormatters/AttributeFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/AttributeFormatters/AttributeFormatter.cs
@@ -77,15 +77,6 @@ public virtual bool TryGetAttributeString(CustomAttribute attribute, out string
                 return false;
             }
 
-            TypeDefinition attrType = attribute.AttributeType as TypeDefinition;
-            if (attrType != null && !DocUtils.IsPublic(attrType)
-                || (FormatterManager.SlashdocFormatter.GetName(attribute.AttributeType) == null)
-                || Array.IndexOf(IgnorableAttributes, attribute.AttributeType.FullName) >= 0)
-            {
-                rval = null;
-                return false;
-            }
-
             var fields = new List<string>();
 
             for (int i = 0; i < attribute.ConstructorArguments.Count; ++i)
@@ -127,11 +118,34 @@ public virtual string MakeAttributesValueString(object argumentValue, TypeRefere
 
         private bool IsIgnoredAttribute(CustomAttribute customAttribute)
         {
+            var attrType = customAttribute.AttributeType;
+
+            if (attrType == null) return true;
+
             // An Obsolete attribute with a known string is added to all ref-like structs
             // https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/span-safety.md#metadata-representation-or-ref-like-structs
-            return customAttribute.AttributeType.FullName == typeof(ObsoleteAttribute).FullName
+            if (attrType.FullName == typeof(ObsoleteAttribute).FullName
                 && customAttribute.HasConstructorArguments
-                && customAttribute.ConstructorArguments.First().Value.ToString() == Consts.RefTypeObsoleteString;
+                && customAttribute.ConstructorArguments.First().Value.ToString() == Consts.RefTypeObsoleteString)
+            {
+                return true;
+            }
+
+            // Expose this attribute in ECMAXML to let ECMA2YML pick up
+            // https://ceapex.visualstudio.com/Engineering/_workitems/edit/550401
+            if (attrType.FullName == Consts.NativeIntegerAttribute)
+            {
+                return false;
+            }
+
+            var attrTypeDef = attrType as TypeDefinition;
+            if (attrTypeDef != null && !DocUtils.IsPublic(attrTypeDef) || (FormatterManager.SlashdocFormatter.GetName(attrType) == null)
+                || Array.IndexOf(IgnorableAttributes, attrType.FullName) >= 0)
+            {
+                return true;
+            }
+
+            return false;
         }
 
         // FIXME: get TypeReferences instead of string comparison?
diff --git a/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs b/mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs
@@ -12,6 +12,12 @@ public class CSharpFullMemberFormatter : MemberFormatter
         public CSharpFullMemberFormatter() : this(null) {}
         public CSharpFullMemberFormatter(TypeMap map) : base(map) { }
 
+        private static readonly Dictionary<string, string> NativeIntTypeMap = new Dictionary<string, string>()
+        {
+            { "System.IntPtr", "nint" },
+            { "System.UIntPtr", "nuint" },
+        };
+
         public override string Language
         {
             get { return "C#"; }
@@ -25,7 +31,7 @@ protected override StringBuilder AppendNamespace (StringBuilder buf, TypeReferen
             return buf;
         }
 
-        protected virtual string GetCSharpType (string t)
+        protected virtual string GetCSharpType(string t)
         {
             // make sure there are no modifiers in the type string (add them back before returning)
             string typeToCompare = t;
@@ -83,6 +89,11 @@ protected override StringBuilder AppendTypeName (StringBuilder buf, TypeReferenc
                 return base.AppendTypeName (buf, type, context);
             }
 
+            if (NativeIntTypeMap.TryGetValue(t, out string typeName) && context.IsNativeInteger())
+            {
+                return buf.Append(typeName);
+            }
+            
             string s = GetCSharpType (t);
             if (s != null)
             {
@@ -137,7 +148,9 @@ protected override StringBuilder AppendSpecialGenericNullableValueTypeName (Stri
             if (genInst.Name.StartsWith ("ValueTuple`"))
             {
                 buf.Append ("(");
-                var genArgList = new List<string> ();
+                var genArgTypeList = new List<string> ();
+                // tuple element names should be traversed before recursion.
+                var genArgNameList = genInst.GenericArguments.Select(arg => context.GetTupleElementName()).ToList();
                 foreach (var item in genInst.GenericArguments)
                 {
                     var isNullableType = false;
@@ -147,11 +160,11 @@ protected override StringBuilder AppendSpecialGenericNullableValueTypeName (Stri
                     }
 
                     var underlyingTypeName = GetTypeName (item, context, appendGeneric, useTypeProjection) + GetTypeNullableSymbol (item, isNullableType);
-                    genArgList.Add (underlyingTypeName);
+                    genArgTypeList.Add (underlyingTypeName);
                 }
-                buf.Append (string.Join (",", genArgList));
+                var genArgList = genInst.GenericArguments.Select((_, index) => string.Format("{0}{1}", genArgTypeList[index], genArgNameList[index] == null ? String.Empty : (" " + genArgNameList[index])));
+                buf.Append (string.Join (", ", genArgList));
                 buf.Append (")");
-
                 return buf;
             }
 
@@ -723,7 +736,14 @@ protected override string GetPropertyDeclaration (PropertyDefinition property)
             {
                 if (set_visible != visibility)
                     buf.Append (' ').Append (set_visible);
-                buf.Append (" set;");
+                if (property.SetMethod.ReturnType is RequiredModifierType returnType && returnType.ModifierType.FullName == Consts.IsExternalInit)
+                {
+                    buf.Append(" init;");
+                }
+                else
+                {
+                    buf.Append(" set;");
+                }
             }
             buf.Append (" }");
 
diff --git a/mdoc/Mono.Documentation/Updater/IAttributeParserContext.cs b/mdoc/Mono.Documentation/Updater/IAttributeParserContext.cs
@@ -5,5 +5,7 @@ public interface IAttributeParserContext
         void NextDynamicFlag();
         bool IsDynamic();
         bool IsNullable();
+        string GetTupleElementName();
+        bool IsNativeInteger();
     }
 }
diff --git a/mdoc/mdoc.Test/FormatterTests.cs b/mdoc/mdoc.Test/FormatterTests.cs
@@ -297,7 +297,7 @@ public void CSharpTuple()
             var member = GetMethod(typeof(NullablesAndTuples), m => m.Name == "TupleReturn");
             var formatter = new CSharpFullMemberFormatter();
             var sig = formatter.GetDeclaration(member);
-            Assert.AreEqual("public (int,string) TupleReturn ();", sig);
+            Assert.AreEqual("public (int, string) TupleReturn ();", sig);
         }
 
         [Test]
@@ -420,6 +420,69 @@ public void CSharpReadOnlyMemberStructTest(string methodName, string expectedSig
             Assert.AreEqual(expectedSignature, methodSignature);
         }
 
+        [Test]
+        public void CSharpTupleNamesTypeTest()
+        {
+            var type = GetType(typeof(SampleClasses.TupleNamesTestClass<,>));
+            var typeSignature = formatter.GetDeclaration(type);
+            Assert.AreEqual("public class TupleNamesTestClass<T1,T2> : IComparable<(T1, T2)>", typeSignature);
+        }
+
+        [Test]
+        public void CSharpTupleNamesPropertyTest()
+        {
+            var property = GetProperty(typeof(SampleClasses.TupleNamesTestClass<,>), m => m.Name == "TuplePropertyType");
+            var propertySignature = formatter.GetDeclaration(property);
+            Assert.AreEqual("public (int a, int b) TuplePropertyType { get; }", propertySignature);
+        }
+
+        [Test]
+        public void CSharpTupleNamesFieldTest()
+        {
+            var field = GetField(GetType(typeof(SampleClasses.TupleNamesTestClass<,>)), "TupleField");
+            var fieldSignature = formatter.GetDeclaration(field);
+            Assert.AreEqual("public (int a, int b, int c) TupleField;", fieldSignature);
+        }
+
+        [TestCase("TupleMethod", "public (int a, int, int b) TupleMethod ((int, int) t1, (int b, int c, int d) t2, (int, int) t3);")]
+        [TestCase("RecursiveTupleMethod", "public ((int a, long b) c, int d) RecursiveTupleMethod ((((int a, long) b, string c) d, (int e, (float f, float g) h) i, int j) t);")]
+        public void CSharpTupleNamesMethodTest(string methodName, string expectedSignature)
+        {
+            var method = GetMethod(typeof(SampleClasses.TupleNamesTestClass<,>), m => m.Name == methodName);
+            var methodSignature = formatter.GetDeclaration(method);
+            Assert.AreEqual(expectedSignature, methodSignature);
+        }
+
+        [TestCase("Property1", "public int Property1 { get; set; }")]
+        [TestCase("Property2", "public int Property2 { get; init; }")]
+        [TestCase("Property3", "public int Property3 { get; protected init; }")]
+        [TestCase("Item", "public int this[int index] { get; init; }")]
+        public void CSharpInitOnlySetterTest(string propertyName, string expectedSignature)
+        {
+            var property = GetProperty(typeof(SampleClasses.InitOnlySetter), p => p.Name == propertyName);
+            var propertySignature = formatter.GetDeclaration(property);
+            Assert.AreEqual(expectedSignature, propertySignature);
+        }
+
+        [Test]
+        public void CSharpNativeIntGenericTypeTest()
+        {
+            var type = GetType(typeof(SampleClasses.GenericNativeIntClass<>));
+            var typeSignature = formatter.GetDeclaration(type);
+            Assert.AreEqual("public class GenericNativeIntClass<nint>", typeSignature);
+        }
+
+        [TestCase("Method1", "public (nint, nuint) Method1 (nint a, nuint b, IntPtr c, UIntPtr d);")]
+        [TestCase("Method2", "public (nint, nuint) Method2 (List<nint> a, Dictionary<int,nuint> b);")]
+        [TestCase("Method3", "public (nint, nuint) Method3 ((nint, nuint) a, (nuint, IntPtr) b, (UIntPtr, string) c);")]
+        [TestCase("Method4", "public (((nint a, IntPtr) b, UIntPtr c) d, (nint e, (nuint f, IntPtr g) h) i) Method4 ();")]
+        public void CSharpNativeIntMethodTest(string methodName, string expectedSignature)
+        {
+            var method = GetMethod(typeof(SampleClasses.NativeIntClass), m => m.Name == methodName);
+            var methodSignature = formatter.GetDeclaration(method);
+            Assert.AreEqual(expectedSignature, methodSignature);
+        }
+
         #region Helper Methods
         string RealTypeName(string name){
             switch (name) {
diff --git a/mdoc/mdoc.Test/MDocUpdaterTests.cs b/mdoc/mdoc.Test/MDocUpdaterTests.cs
@@ -1,11 +1,9 @@
 ﻿using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Xml;
 using mdoc.Test.SampleClasses;
 using Mono.Cecil;
-using Mono.Cecil.Rocks;
 using Mono.Collections.Generic;
 using Mono.Documentation;
 using Mono.Documentation.Updater;
@@ -31,6 +29,16 @@ public void Test_GetCustomAttributes_IgnoredObsoleteAttribute()
             Assert.IsFalse(formatter.TryGetAttributeString(attributes.First(), out string rval));
         }
 
+        [Test]
+        public void Test_GetCustomAttributes_EmitNativeIntegerAttribute()
+        {
+            var method = GetMethod(typeof(SampleClasses.NativeIntClass), "Method1");
+            static CustomAttribute GetNativeIntegerAttr(ParameterDefinition p) => p?.CustomAttributes.Where(attr => attr.AttributeType.FullName == Consts.NativeIntegerAttribute).FirstOrDefault();
+            Assert.IsNotNull(GetNativeIntegerAttr(method.Parameters[0]));
+            Assert.IsTrue(formatter.TryGetAttributeString(GetNativeIntegerAttr(method.Parameters[0]), out string rval));
+            Assert.IsNull(GetNativeIntegerAttr(method.Parameters[2]));
+        }
+
         [Test]
         public void Test_GetDocParameterType_CppGenericParameterType_ReturnsTypeWithGenericParameters()
         {
diff --git a/mdoc/mdoc.Test/NullableReferenceTypesTests.cs b/mdoc/mdoc.Test/NullableReferenceTypesTests.cs
@@ -36,10 +36,10 @@ public class NullableReferenceTypesTests : BasicFormatterTests<CSharpMemberForma
         [TestCase("Tuple<int,int>?", "NullableTupleOfValueType")]
         [TestCase("Tuple<int?,int?>", "TupleOfNullableValueType")]
         [TestCase("Tuple<int?,int?>?", "NullableTupleOfNullableValueType")]
-        [TestCase("(int,int)", "ValueTupleOfValueType")]
-        [TestCase("(int,int)?", "NullableValueTupleOfValueType")]
-        [TestCase("(int?,int?)", "ValueTupleOfNullableValueType")]
-        [TestCase("(int?,int?)?", "NullableValueTupleOfNullableValueType")]
+        [TestCase("(int, int)", "ValueTupleOfValueType")]
+        [TestCase("(int, int)?", "NullableValueTupleOfValueType")]
+        [TestCase("(int?, int?)", "ValueTupleOfNullableValueType")]
+        [TestCase("(int?, int?)?", "NullableValueTupleOfNullableValueType")]
         [TestCase("ICollection<int>", "InterfaceOfValueType")]
         [TestCase("ICollection<int>?", "NullableInterfaceOfValueType")]
         [TestCase("ICollection<int?>?", "NullableInterfaceOfNullableValueType")]
@@ -83,10 +83,10 @@ public class NullableReferenceTypesTests : BasicFormatterTests<CSharpMemberForma
         [TestCase("Tuple<string,string>?", "NullableTupleOfReferenceType")]
         [TestCase("Tuple<string?,string?>", "TupleOfNullableReferenceType")]
         [TestCase("Tuple<string?,string?>?", "NullableTupleOfNullableReferenceType")]
-        [TestCase("(string,string)", "ValueTupleOfReferenceType")]
-        [TestCase("(string,string)?", "NullableValueTupleOfReferenceType")]
-        [TestCase("(string?,string?)", "ValueTupleOfNullableReferenceType")]
-        [TestCase("(string?,string?)?", "NullableValueTupleOfNullableReferenceType")]
+        [TestCase("(string, string)", "ValueTupleOfReferenceType")]
+        [TestCase("(string, string)?", "NullableValueTupleOfReferenceType")]
+        [TestCase("(string?, string?)", "ValueTupleOfNullableReferenceType")]
+        [TestCase("(string?, string?)?", "NullableValueTupleOfNullableReferenceType")]
         [TestCase("ICollection<string>", "InterfaceOfReferenceType")]
         [TestCase("ICollection<string>?", "NullableInterfaceOfReferenceType")]
         [TestCase("ICollection<string?>?", "NullableInterfaceOfNullableReferenceType")]
diff --git a/mdoc/mdoc.Test/SampleClasses/InitOnlySetter.cs b/mdoc/mdoc.Test/SampleClasses/InitOnlySetter.cs
diff --git a/mdoc/mdoc.Test/SampleClasses/IsExternalInit.cs b/mdoc/mdoc.Test/SampleClasses/IsExternalInit.cs
diff --git a/mdoc/mdoc.Test/SampleClasses/NativeIntClass.cs b/mdoc/mdoc.Test/SampleClasses/NativeIntClass.cs
diff --git a/mdoc/mdoc.Test/SampleClasses/TupleNamesTestClass.cs b/mdoc/mdoc.Test/SampleClasses/TupleNamesTestClass.cs
diff --git a/mdoc/mdoc.nuspec b/mdoc/mdoc.nuspec

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@ namespace Mono.Documentation`
`3`	`3`	`{`
`4`	`4`	`public static class Consts`
`5`	`5`	`{`
`6`		`- public static string MonoVersion = "5.8.7";`
	`6`	`+ public static string MonoVersion = "5.8.8";`
`7`	`7`	`public const string DocId = "DocId";`
`8`	`8`	`public const string CppCli = "C++ CLI";`
`9`	`9`	`public const string CppCx = "C++ CX";`
`@@ -49,5 +49,8 @@ public static class Consts`
`49`	`49`	`public const string IsByRefLikeAttribute = "System.Runtime.CompilerServices.IsByRefLikeAttribute";`
`50`	`50`	`public const string IsReadOnlyAttribute = "System.Runtime.CompilerServices.IsReadOnlyAttribute";`
`51`	`51`	`public const string InAttribute = "System.Runtime.InteropServices.InAttribute";`
	`52`	`+ public const string TupleElementNamesAttribute = "System.Runtime.CompilerServices.TupleElementNamesAttribute";`
	`53`	`+ public const string IsExternalInit = "System.Runtime.CompilerServices.IsExternalInit";`
	`54`	`+ public const string NativeIntegerAttribute = "System.Runtime.CompilerServices.NativeIntegerAttribute";`
`52`	`55`	`}`
`53`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3997,7 +3997,7 @@ public void MakeParameters (XmlElement root, MemberReference member, IList<Param`
`3997`	`3997`	`xelement.RemoveAttribute(Consts.Index);`
`3998`	`3998`	`xelement.SetAttribute(Consts.Index, i.ToString());`
`3999`	`3999`	`xelement.SetAttribute (Consts.FrameworkAlternate, fxaValue);`
`4000`		`-`
	`4000`	`+ MakeParamsAttributes(xelement, AttributeFormatter.PreProcessCustomAttributes(p.Definition.CustomAttributes), typeEntry, member);`
`4001`	`4001`	`continue;`
`4002`	`4002`	`}`
`4003`	`4003`	`else {`
Original file line number	Diff line number	Diff line change
`@@ -26,5 +26,15 @@ public bool IsNullable()`
`26`	`26`	`{`
`27`	`27`	`return false;`
`28`	`28`	`}`
	`29`	`+`
	`30`	`+ public string GetTupleElementName()`
	`31`	`+ {`
	`32`	`+ return null;`
	`33`	`+ }`
	`34`	`+`
	`35`	`+ public bool IsNativeInteger()`
	`36`	`+ {`
	`37`	`+ return false;`
	`38`	`+ }`
`29`	`39`	`}`
`30`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,5 +5,7 @@ public interface IAttributeParserContext`
`5`	`5`	`void NextDynamicFlag();`
`6`	`6`	`bool IsDynamic();`
`7`	`7`	`bool IsNullable();`
	`8`	`+ string GetTupleElementName();`
	`9`	`+ bool IsNativeInteger();`
`8`	`10`	`}`
`9`	`11`	`}`