implemented __signature__ on methodbinding

lostmsu · lostmsu · commit 6a0c1aa05117 · 2020-05-16T13:57:37.000-07:00
diff --git a/src/embed_tests/Inspect.cs b/src/embed_tests/Inspect.cs
@@ -27,7 +27,8 @@ public void BoundMethodsAreInspectable() {
         }
 
         class Class {
-            public void Method() { }
+            public void Method(int a, int b = 10) { }
+            public void Method(int a, object b) { }
         }
     }
 }
diff --git a/src/runtime/methodbinding.cs b/src/runtime/methodbinding.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 
 namespace Python.Runtime
@@ -59,6 +60,47 @@ public static IntPtr mp_subscript(IntPtr tp, IntPtr idx)
             return mb.pyHandle;
         }
 
+        PyObject Singature {
+            get {
+                var infos = this.info == null ? this.m.info : new[] {this.info};
+                // this is a primitive version
+                // the overload with the maximum number of parameters should be used
+                var primary = infos.First();
+                var primaryParameters = primary.GetParameters();
+                PyObject signatureClass = Runtime.InspectModule.GetAttr("Signature");
+                var primaryReturn = primary.ReturnParameter;
+                if (infos.Any(i => i.GetParameters().Length != primaryParameters.Length
+                                   || i.ReturnParameter?.ParameterType != primaryReturn?.ParameterType)) {
+                    return signatureClass.Invoke();
+                }
+
+                var parameters = new PyList();
+                var parameterClass = primaryParameters.Length > 0 ? Runtime.InspectModule.GetAttr("Parameter") : null;
+                var positionalOrKeyword = primaryParameters.Length > 0 ? parameterClass.GetAttr("POSITIONAL_OR_KEYWORD") : null;
+                for (int i = 0; i < primaryParameters.Length; i++) {
+                    var parameter = primaryParameters[i];
+                    var alternatives = infos.Select(info => info.GetParameters()[i]);
+                    var defaultValue = alternatives
+                        .Select(alternative => alternative.DefaultValue != DBNull.Value ? alternative.DefaultValue.ToPython() : null)
+                        .FirstOrDefault(v => v != null) ?? parameterClass.GetAttr("empty");
+
+                    if (alternatives.Any(alternative => alternative.Name != parameter.Name)) {
+                        return signatureClass.Invoke();
+                    }
+
+                    var args = new PyTuple(new []{ parameter.Name.ToPython(), positionalOrKeyword});
+                    var kw = new PyDict();
+                    if (defaultValue != null) {
+                        kw["default"] = defaultValue;
+                    }
+                    var parameterInfo = parameterClass.Invoke(args: args, kw: kw);
+                    parameters.Append(parameterInfo);
+                }
+
+                // TODO: add return annotation
+                return signatureClass.Invoke(parameters);
+            }
+        }
 
         /// <summary>
         /// MethodBinding __getattribute__ implementation.
@@ -85,6 +127,9 @@ public static IntPtr tp_getattro(IntPtr ob, IntPtr key)
                 case "Overloads":
                     var om = new OverloadMapper(self.m, self.target);
                     return om.pyHandle;
+                case "__signature__":
+                    var sig = self.Singature;
+                    return sig.Handle;
                 default:
                     return Runtime.PyObject_GenericGetAttr(ob, key);
             }
diff --git a/src/runtime/runtime.cs b/src/runtime/runtime.cs
@@ -509,6 +509,10 @@ public static PyObject None
             }
         }
 
+        private static readonly Lazy<PyObject> inspect =
+            new Lazy<PyObject>(() => PythonEngine.ImportModule("inspect"), isThreadSafe: false);
+        public static PyObject InspectModule => inspect.Value;
+
         /// <summary>
         /// Check if any Python Exceptions occurred.
         /// If any exist throw new PythonException.

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,8 @@ public void BoundMethodsAreInspectable() {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`class Class {`
`30`		`- public void Method() { }`
	`30`	`+ public void Method(int a, int b = 10) { }`
	`31`	`+ public void Method(int a, object b) { }`
`31`	`32`	`}`
`32`	`33`	`}`
`33`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -509,6 +509,10 @@ public static PyObject None`
`509`	`509`	`}`
`510`	`510`	`}`
`511`	`511`
	`512`	`+ private static readonly Lazy<PyObject> inspect =`
	`513`	`+ new Lazy<PyObject>(() => PythonEngine.ImportModule("inspect"), isThreadSafe: false);`
	`514`	`+ public static PyObject InspectModule => inspect.Value;`
	`515`	`+`
`512`	`516`	`/// <summary>`
`513`	`517`	`/// Check if any Python Exceptions occurred.`
`514`	`518`	`/// If any exist throw new PythonException.`