.NET7: Support static abstract/virtual modifiers

mdoc/Consts.cs

@@ -54,6 +54,8 @@ public static class Consts
         public const string TupleElementNamesAttribute = "System.Runtime.CompilerServices.TupleElementNamesAttribute";
         public const string IsExternalInit = "System.Runtime.CompilerServices.IsExternalInit";
         public const string NativeIntegerAttribute = "System.Runtime.CompilerServices.NativeIntegerAttribute";
+        public const string ScopedRefAttribute= "System.Runtime.CompilerServices.ScopedRefAttribute";
+        public const string LifetimeAnnotationAttribute = "System.Runtime.CompilerServices.LifetimeAnnotationAttribute";
         public const string CallConvPrefix = "System.Runtime.CompilerServices.CallConv";
     }
 }

mdoc/Mono.Documentation/Updater/DocUtils.cs

@@ -161,7 +161,12 @@ public static IEnumerable<T> SafeCast<T> (this System.Collections.IEnumerable li
 
         public static bool IsExplicitlyImplemented (MethodDefinition method)
         {
-            return method != null && method.IsPrivate && method.IsFinal && method.IsVirtual;
+            if (method == null || !method.IsPrivate)
+            {
+                return false;
+            }
+            // Support EII for static abstract members in interface
+            return (method.IsFinal && method.IsVirtual) || (method.IsStatic && method.HasOverrides);
         }
 
         public static string GetTypeDotMember (string name)
@@ -838,7 +843,7 @@ public static bool IsDestructor(MethodDefinition method)
 
         public static bool IsOperator(MethodReference method)
         {
-            return method.Name.StartsWith("op_", StringComparison.Ordinal);
+            return method.Name.Split('.').Last().StartsWith("op_", StringComparison.Ordinal);
         }
 
         public static bool DocIdCheck(XmlNode a, XmlElement b)

mdoc/Mono.Documentation/Updater/Formatters/CSharpFullMemberFormatter.cs

@@ -380,79 +380,81 @@ protected override string GetMethodDeclaration (MethodDefinition method)
             return null;
         }
 
-        protected override StringBuilder AppendMethodName (StringBuilder buf, MethodDefinition method)
+        protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
         {
-            if (DocUtils.IsExplicitlyImplemented (method))
+            var methodName = method.Name;
+            if (DocUtils.IsExplicitlyImplemented(method))
             {
                 TypeReference iface;
                 MethodReference ifaceMethod;
-                DocUtils.GetInfoForExplicitlyImplementedMethod (method, out iface, out ifaceMethod);
-                return buf.Append (new CSharpMemberFormatter (this.TypeMap).GetName (iface))
-                    .Append ('.')
-                    .Append (ifaceMethod.Name);
+                DocUtils.GetInfoForExplicitlyImplementedMethod(method, out iface, out ifaceMethod);
+                buf.Append(new CSharpMemberFormatter(this.TypeMap).GetName(iface)).Append('.');
+                methodName = ifaceMethod.Name;
             }
 
-            if (method.Name.StartsWith ("op_", StringComparison.Ordinal))
+            if (methodName.StartsWith("op_", StringComparison.Ordinal))
             {
                 // this is an operator
-                switch (method.Name)
+                switch (methodName)
                 {
                     case "op_Implicit":
                     case "op_Explicit":
                         buf.Length--; // remove the last space, which assumes a member name is coming
                         return buf;
                     case "op_Addition":
                     case "op_UnaryPlus":
-                        return buf.Append ("operator +");
+                        return buf.Append("operator +");
                     case "op_Subtraction":
                     case "op_UnaryNegation":
-                        return buf.Append ("operator -");
+                        return buf.Append("operator -");
                     case "op_Division":
-                        return buf.Append ("operator /");
+                        return buf.Append("operator /");
                     case "op_Multiply":
-                        return buf.Append ("operator *");
+                        return buf.Append("operator *");
                     case "op_Modulus":
-                        return buf.Append ("operator %");
+                        return buf.Append("operator %");
                     case "op_BitwiseAnd":
-                        return buf.Append ("operator &");
+                        return buf.Append("operator &");
                     case "op_BitwiseOr":
-                        return buf.Append ("operator |");
+                        return buf.Append("operator |");
                     case "op_ExclusiveOr":
-                        return buf.Append ("operator ^");
+                        return buf.Append("operator ^");
                     case "op_LeftShift":
-                        return buf.Append ("operator <<");
+                        return buf.Append("operator <<");
                     case "op_RightShift":
-                        return buf.Append ("operator >>");
+                        return buf.Append("operator >>");
                     case "op_LogicalNot":
-                        return buf.Append ("operator !");
+                        return buf.Append("operator !");
                     case "op_OnesComplement":
-                        return buf.Append ("operator ~");
+                        return buf.Append("operator ~");
                     case "op_Decrement":
-                        return buf.Append ("operator --");
+                        return buf.Append("operator --");
                     case "op_Increment":
-                        return buf.Append ("operator ++");
+                        return buf.Append("operator ++");
                     case "op_True":
-                        return buf.Append ("operator true");
+                        return buf.Append("operator true");
                     case "op_False":
-                        return buf.Append ("operator false");
+                        return buf.Append("operator false");
                     case "op_Equality":
-                        return buf.Append ("operator ==");
+                        return buf.Append("operator ==");
                     case "op_Inequality":
-                        return buf.Append ("operator !=");
+                        return buf.Append("operator !=");
                     case "op_LessThan":
-                        return buf.Append ("operator <");
+                        return buf.Append("operator <");
                     case "op_LessThanOrEqual":
-                        return buf.Append ("operator <=");
+                        return buf.Append("operator <=");
                     case "op_GreaterThan":
-                        return buf.Append ("operator >");
+                        return buf.Append("operator >");
                     case "op_GreaterThanOrEqual":
-                        return buf.Append ("operator >=");
+                        return buf.Append("operator >=");
                     default:
-                        return base.AppendMethodName (buf, method);
+                        return buf.Append(methodName);
                 }
             }
             else
-                return base.AppendMethodName (buf, method);
+            {
+                return buf.Append(methodName);
+            }
         }
 
         protected override string GetTypeNullableSymbol(TypeReference type, bool? isNullableType)
@@ -519,14 +521,16 @@ protected override StringBuilder AppendModifiers (StringBuilder buf, MethodDefin
             if (method.IsStatic) modifiers += " static";
             if (method.IsVirtual && !method.IsAbstract)
             {
-                if ((method.Attributes & MethodAttributes.NewSlot) != 0) modifiers += " virtual";
+                if ((method.Attributes & MethodAttributes.NewSlot) != 0 || method.IsStatic) modifiers += " virtual";
                 else modifiers += " override";
             }
             TypeDefinition declType = (TypeDefinition)method.DeclaringType;
-            if (method.IsAbstract && !declType.IsInterface) modifiers += " abstract";
+            if (method.IsAbstract && (!declType.IsInterface || method.IsStatic)) modifiers += " abstract";
             if (method.IsFinal) modifiers += " sealed";
             if (modifiers == " virtual sealed") modifiers = "";
-            if (declType.IsValueType && DocUtils.HasCustomAttribute(method, Consts.IsReadOnlyAttribute))
+            if (declType.IsValueType 
+                && !(method.IsSpecialName && method.Name.StartsWith("get_")) // Property without set method is by defualt readonly.
+                && DocUtils.HasCustomAttribute(method, Consts.IsReadOnlyAttribute))
             {
                 modifiers += buf.Length == 0 ? "readonly" : " readonly";
             }
@@ -541,7 +545,7 @@ protected override StringBuilder AppendModifiers (StringBuilder buf, MethodDefin
                     break;
             }
 
-            return buf.Append (modifiers);
+            return buf.Append (buf.Length == 0 ? modifiers.TrimStart() : modifiers);
         }
 
         protected override StringBuilder AppendRefTypeName(StringBuilder buf, ByReferenceType type, IAttributeParserContext context)
@@ -610,7 +614,9 @@ protected override StringBuilder AppendParameter(StringBuilder buf, ParameterDef
 
             if (parameter.HasCustomAttributes)
             {
-                var isScoped = parameter.CustomAttributes.Any(ca => ca.AttributeType.Name == "LifetimeAnnotationAttribute");
+                var isScoped = parameter.CustomAttributes.Any(
+                    ca => ca.AttributeType.FullName == Consts.ScopedRefAttribute
+                    || ca.AttributeType.FullName == Consts.LifetimeAnnotationAttribute); // Workaround as complier in ci pipeline has delay for update.
                 if (isScoped)
                     buf.AppendFormat("scoped ");
             }
@@ -698,23 +704,8 @@ protected override string GetPropertyDeclaration (PropertyDefinition property)
             if (method == null)
                 method = property.GetMethod;
 
-            string modifiers = String.Empty;
-            if (method.IsStatic) modifiers += " static";
-            if (method.IsVirtual && !method.IsAbstract)
-            {
-                if ((method.Attributes & MethodAttributes.NewSlot) != 0)
-                    modifiers += " virtual";
-                else
-                    modifiers += " override";
-            }
-            TypeDefinition declDef = (TypeDefinition)method.DeclaringType;
-            if (method.IsAbstract && !declDef.IsInterface)
-                modifiers += " abstract";
-            if (method.IsFinal)
-                modifiers += " sealed";
-            if (modifiers == " virtual sealed")
-                modifiers = "";
-            buf.Append (modifiers).Append (' ');
+            AppendModifiers(buf, method);
+            buf.Append(' ');
 
             var context = AttributeParserContext.Create (property);
             var isNullableType = context.IsNullable ();

mdoc/Mono.Documentation/Updater/Formatters/CppFormatters/CppFullMemberFormatter.cs

@@ -480,11 +480,19 @@ protected virtual StringBuilder AppendExplisitImplementationMethod(StringBuilder
 
         protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
         {
-            if (!method.Name.StartsWith("op_", StringComparison.Ordinal))
-                return base.AppendMethodName(buf, method);
+            var methodName = method.Name;
+            int dotIndex = methodName.LastIndexOf('.');
+            if (dotIndex != -1)
+            {
+                buf.Append(methodName.Substring(0, dotIndex + 1));
+                methodName = methodName.Substring(dotIndex + 1);
+            }
+
+            if (!methodName.StartsWith("op_", StringComparison.Ordinal))
+                return buf.Append(methodName);
 
             // this is an operator
-            switch (method.Name)
+            switch (methodName)
             {
                 case "op_Implicit":
                 case "op_Explicit":
@@ -537,9 +545,8 @@ protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefin
                 case "op_GreaterThanOrEqual":
                     return buf.Append("operator >=");
                 default:
-                    return base.AppendMethodName(buf, method);
+                    return buf.Append(methodName);
             }
-
         }
 
         protected override StringBuilder AppendGenericMethodConstraints (StringBuilder buf, MethodDefinition method)

mdoc/Mono.Documentation/Updater/Formatters/FSharpFormatter.cs

@@ -537,7 +537,7 @@ private FSharpMethodKind GetMethodKind(MethodDefinition method)
 
         private void AppendModuleMethod(StringBuilder buf, MethodDefinition method)
         {
-            if (!IsOperator(method))
+            if (!DocUtils.IsOperator(method))
             {
                 buf.Append($"{GetModuleName(method.DeclaringType)}.");
             }
@@ -591,7 +591,7 @@ private void AppendMethodDeclarationEnding(StringBuilder buf, MethodDefinition m
 
         protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
         {
-            if (IsOperator(method))
+            if (DocUtils.IsOperator(method))
             {
                 // this is an operator
                 if (TryAppendOperatorName(buf, method))
@@ -874,11 +874,12 @@ private CustomAttribute GetCustomAttribute(Collection<CustomAttribute> customAtt
 
         protected bool TryAppendOperatorName(StringBuilder buf, MethodDefinition method)
         {
-            if (!IsOperator(method))
+            if (!DocUtils.IsOperator(method))
                 return false;
-            if (operators.ContainsKey(method.Name))
+            var methodName = method.Name.Split('.').Last();
+            if (operators.ContainsKey(methodName))
             {
-                buf.Append($"( {operators[method.Name]} )");
+                buf.Append($"( {operators[methodName]} )");
                 return true;
             }
 
@@ -925,11 +926,6 @@ protected override StringBuilder AppendPointerTypeName(StringBuilder buf, TypeRe
         }
 
         #region "Is" methods
-        private static bool IsOperator(MethodDefinition method)
-        {
-            return method.Name.StartsWith("op_", StringComparison.Ordinal);
-        }
-
         private static bool IsFSharpFunction(TypeReference type)
         {
             return type.FullName.StartsWith("Microsoft.FSharp.Core.FSharpFunc`");
@@ -984,16 +980,11 @@ protected override StringBuilder AppendVisibility(StringBuilder buf, MethodDefin
         {
             if (method.IsPublic
                 || method.IsFamily
-                || method.IsFamilyOrAssembly || IsExplicitlyImplemented(method))
+                || method.IsFamilyOrAssembly || DocUtils.IsExplicitlyImplemented(method))
                 return buf.Append("");
             return null;
         }
 
-        public static bool IsExplicitlyImplemented(MethodDefinition method)
-        {
-            return method != null && method.IsPrivate && method.IsFinal && method.IsVirtual;
-        }
-
         private static string GetTypeVisibility(TypeAttributes ta)
         {
             switch (ta & TypeAttributes.VisibilityMask)

mdoc/Mono.Documentation/Updater/Formatters/VBFullMemberFormatter.cs

@@ -394,15 +394,14 @@ protected override string GetMethodDeclaration(MethodDefinition method)
 
         protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefinition method)
         {
-            if (DocUtils.IsExplicitlyImplemented(method))
-            {
-                return buf.Append(method.Name.Split('.').Last());
-            }
+            var methodName = DocUtils.IsExplicitlyImplemented(method) 
+                ? method.Name.Split('.').Last() 
+                : method.Name;
 
             if (DocUtils.IsOperator(method))
             {
                 // this is an operator
-                switch (method.Name)
+                switch (methodName)
                 {
                     case "op_Implicit":
                     case "op_Explicit":
@@ -455,11 +454,13 @@ protected override StringBuilder AppendMethodName(StringBuilder buf, MethodDefin
                     case "op_Like":
                         return buf.Append("Operator Like");
                     default:
-                        return base.AppendMethodName(buf, method);
+                        return buf.Append(methodName);
                 }
             }
             else
-                return base.AppendMethodName(buf, method);
+            {
+                return buf.Append(methodName);
+            }
         }
 
         protected override StringBuilder AppendGenericMethodConstraints(StringBuilder buf, MethodDefinition method)

mdoc/mdoc.Test/CppFullFormatterTests.cs

@@ -321,7 +321,16 @@ public void MethodSignature_ParamsKeyword_M6()
  void M6(int i, ... cli::array <System::Object ^> ^ args);",
                 "M6");
         }
-
+
+        [TestCase("StaticVirtualMembers.Derived",
+            "StaticVirtualMembers.StaticVirtualMemberInInterface<StaticVirtualMembers.Derived,StaticVirtualMembers.Derived,System.Int32>.op_Addition",
+            " static int StaticVirtualMembers.StaticVirtualMemberInInterface<StaticVirtualMembers.Derived,StaticVirtualMembers.Derived,System.Int32>.operator +(StaticVirtualMembers::Derived ^ left, StaticVirtualMembers::Derived ^ right) = StaticVirtualMembers::StaticVirtualMemberInInterface<StaticVirtualMembers::Derived ^, StaticVirtualMembers::Derived ^, int>::op_Addition;")]
+        public void CppCLIStaticOperatorImplementation(string typeFullName, string methodName, string expectedSignature)
+        {
+            var staticVirtualMemberDllPath = "../../../../external/Test/StaticVirtualMembers.dll";
+            TestMethodSignature(staticVirtualMemberDllPath, typeFullName, methodName, expectedSignature);
+        }
+
         protected override TypeDefinition GetType(Type type)
         {
             var moduleName = type.Module.FullyQualifiedName;

mdoc/mdoc.Test/FSharp/FSharpFormatterTests.cs

@@ -904,6 +904,16 @@ public void Operators_3() =>
 @"( +? ) : int -> int -> int",
 "op_PlusQmark");
 
+        [Category("Operators")]
+        [TestCase("StaticVirtualMembers.Derived",
+            "StaticVirtualMembers.StaticVirtualMemberInInterface<StaticVirtualMembers.Derived,StaticVirtualMembers.Derived,System.Int32>.op_Addition",
+            "static member ( + ) : Derived * Derived -> int")]
+        public void FSharpStaticOperatorImplementation(string typeFullName, string methodName, string expectedSignature)
+        {
+            var staticVirtualMemberDllPath = "../../../../external/Test/StaticVirtualMembers.dll";
+            TestMethodSignature(staticVirtualMemberDllPath, typeFullName, methodName, expectedSignature);
+        }
+
         #endregion
 
         #region UnitsOfMeasure

mdoc/mdoc.Test/FSharp/FSharpUsageFormatterTests.cs

@@ -127,6 +127,17 @@ public void MethodUsage_11() =>
 "func <||| (arg1, arg2, arg3)",
 "op_PipeLeft3");
 
+        [Category("Usage")]
+        [Category("Operators")]
+        [TestCase("StaticVirtualMembers.Derived",
+            "StaticVirtualMembers.StaticVirtualMemberInInterface<StaticVirtualMembers.Derived,StaticVirtualMembers.Derived,System.Int32>.op_Addition",
+            "left + right")]
+        public void FSharpStaticOperatorImplementation(string typeFullName, string methodName, string expectedSignature)
+        {
+            var staticVirtualMemberDllPath = "../../../../external/Test/StaticVirtualMembers.dll";
+            TestMethodSignature(staticVirtualMemberDllPath, typeFullName, methodName, expectedSignature);
+        }
+
         [Test]
         [Category("Usage")]
         [Category("Methods")]