Merge pull request #544 from mono/develop

🚢 5.8.2

Author: anmeng10101

external/Test/mdoc.Test.FSharp.dll

@@ -4,6 +4,7 @@ The files in this directory are used as test inputs for explicit assembly testin
 |---|---|
 |CSharpExample.dll|TBD|
 |mdoc.Test.Cplusplus.dll|../../mdoc/mdoc.Test.Cplusplus|
+|mdoc.Test.NullableReferenceTypes.dll|../../mdoc/mdoc.Test/NullableReferenceTypesTests|
 |UWPTestComponentCSharp.winmd|../../mdoc/mdoc.Test/UWPTestComponentCSharp|
 |UwpTestWinRtComponentCpp.dll|../../mdoc/mdoc.Test/UwpTestWinRtComponentCpp|
 |UwpTestWinRtComponentCpp.winmd|../../mdoc/mdoc.Test/UwpTestWinRtComponentCpp|

external/Test/mdoc.Test.NullableReferenceTypes.dll

@@ -3,7 +3,7 @@ namespace Mono.Documentation
 {
 	public static class Consts
 	{
-		public static string MonoVersion = "5.8";
+		public static string MonoVersion = "5.8.2";
 		public const string DocId = "DocId";
 		public const string CppCli = "C++ CLI";
 	    public const string CppCx = "C++ CX";

external/Test/readme.md

@@ -3801,7 +3801,7 @@ public static void MakeAttributes(
             XmlElement e = (XmlElement)root.SelectSingleNode("Attributes");
             if (e == null)
                 e = root.OwnerDocument.CreateElement("Attributes");
-            if (isFirstFramework)
+            if (isFirstFramework && typeEntry?.TimesProcessed == 1)
             {
                 e.RemoveAll();
             }

mdoc/Consts.cs

@@ -0,0 +1,92 @@
+using mdoc.Mono.Documentation.Updater;
+using Mono.Cecil;
+using Mono.Documentation.Util;
+using System;
+using System.Collections.ObjectModel;
+
+namespace Mono.Documentation.Updater
+{
+    public class AttributeParserContext : IAttributeParserContext
+    {
+        private int nullableAttributeIndex;
+        private int dynamicAttributeIndex;
+        private ICustomAttributeProvider provider;
+        private ReadOnlyCollection<bool?> nullableAttributeFlags;
+        private ReadOnlyCollection<bool> dynamicAttributeFlags;
+
+        private AttributeParserContext(ICustomAttributeProvider provider)
+        {
+            this.provider = provider;
+
+            ReadDynamicAttribute();
+            ReadNullableAttribute();
+        }
+
+        private bool ExistsNullableAttribute
+        {
+            get
+            {
+                return nullableAttributeFlags.Count > 0;
+            }
+        }
+
+        private bool HasSameNullableValue
+        {
+            get
+            {
+                return nullableAttributeFlags.Count == 1;
+            }
+        }
+
+        public static IAttributeParserContext Create(ICustomAttributeProvider provider)
+        {
+            return new AttributeParserContext(provider);
+        }
+
+        public void NextDynamicFlag()
+        {
+            dynamicAttributeIndex++;
+        }
+
+        public bool IsDynamic()
+        {
+            return dynamicAttributeFlags != null && (dynamicAttributeFlags.Count == 0 || dynamicAttributeFlags[dynamicAttributeIndex]);
+        }
+
+        public bool IsNullable()
+        {
+            if (ExistsNullableAttribute)
+            {
+                if (HasSameNullableValue)
+                {
+                    return nullableAttributeFlags[0].IsTrue();
+                }
+
+                if (nullableAttributeIndex < nullableAttributeFlags.Count)
+                {
+                    return nullableAttributeFlags[nullableAttributeIndex++].IsTrue();
+                }
+
+                throw new IndexOutOfRangeException("You are out of range in the nullable attribute values, please call the method for each nullable checking only once.");
+            }
+
+            return false;
+        }
+
+        private void ReadDynamicAttribute()
+        {
+            DynamicTypeProvider dynamicTypeProvider = new DynamicTypeProvider(provider);
+            var dynamicTypeFlags = dynamicTypeProvider.GetDynamicTypeFlags();
+            if (dynamicTypeFlags != null)
+            {
+                dynamicAttributeFlags = new ReadOnlyCollection<bool>(dynamicTypeFlags);
+            }
+        }
+
+        private void ReadNullableAttribute()
+        {
+            NullableReferenceTypeProvider nullableReferenceTypeProvider = new NullableReferenceTypeProvider(provider);
+            nullableAttributeFlags = new ReadOnlyCollection<bool?>(nullableReferenceTypeProvider.GetNullableReferenceTypeFlags());
+        }
+    }
+}

mdoc/Mono.Documentation/MDocUpdater.cs

@@ -928,5 +928,22 @@ public static bool IsEiiIgnoredMethod(MethodReference method, MethodReference im
 
             return false;
         }
+
+        public static TypeDefinition FixUnnamedParameters(TypeDefinition type)
+        {
+            foreach (var method in type.Methods)
+            {
+                var unnamedParameterIndex = 1;
+                foreach (var item in method.Parameters)
+                {
+                    if (string.IsNullOrEmpty(item.Name))
+                    {
+                        item.Name = $"unnamedParam{unnamedParameterIndex++}";
+                    }
+                }
+            }
+
+            return type;
+        }
     }
 }

mdoc/Mono.Documentation/Updater/AttributeParserContext.cs

@@ -27,7 +27,7 @@ protected IEnumerable<TypeDefinition> GetDocumentationTypes (AssemblyDefinition
                     continue;
                 if (seen != null && seen.Contains (type.FullName))
                     continue;
-                yield return type;
+                yield return DocUtils.FixUnnamedParameters (type);
             }
         }
 

mdoc/Mono.Documentation/Updater/DocUtils.cs

@@ -0,0 +1,47 @@
+using Mono.Cecil;
+using Mono.Documentation.Updater;
+using Mono.Documentation.Util;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace mdoc.Mono.Documentation.Updater
+{
+    public class DynamicTypeProvider
+    {
+        private const string DynamicAttributeFulleName = "System.Runtime.CompilerServices.DynamicAttribute";
+
+        private ICustomAttributeProvider provider;
+
+        public DynamicTypeProvider(ICustomAttributeProvider provider)
+        {
+            this.provider = provider;
+        }
+
+        public IList<bool> GetDynamicTypeFlags()
+        {
+            CustomAttribute dynamicAttribute = FindDynamicAttribute();
+            if (dynamicAttribute != null)
+            {
+                CustomAttributeArgument[] attributeValues = new CustomAttributeArgument[0];
+                if (dynamicAttribute.ConstructorArguments.Count > 0)
+                {
+                    attributeValues = (CustomAttributeArgument[])dynamicAttribute.ConstructorArguments[0].Value;
+                }
+
+                return attributeValues.Select(t => (bool)t.Value).ToList();
+            }
+
+            return null;
+        }
+
+        private CustomAttribute FindDynamicAttribute()
+        {
+            if (provider.HasCustomAttributes)
+            {
+                return provider.CustomAttributes.SafeCast<CustomAttribute>().SingleOrDefault(ca => ca.GetDeclaringType() == DynamicAttributeFulleName);
+            }
+
+            return null;
+        }
+    }
+}