Address @tminka's comments.

christabella · christabella · commit f19c28162185 · 2020-12-23T09:15:26.000Z
diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
@@ -21,13 +21,6 @@ public void Dispose()
             PythonEngine.Shutdown();
         }
 
-        public class SampleClass
-        {
-            public int VoidCall() => 10;
-
-            public int Foo(int a, int b = 10) => a + b;
-        }
-
         public class OperableObject
         {
             public int Num { get; set; }
diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -343,11 +343,6 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                 int kwargsMatched;
                 int defaultsNeeded;
                 bool isOperator = OperatorMethod.IsOperatorMethod(mi);  // e.g. op_Addition is defined for OperableObject
-                if (isOperator )
-                {
-                    var a = 0;
-                    a++;
-                }
                 if (!MatchesArgumentCount(pynargs, pi, kwargDict, isOperator, out paramsArray, out defaultArgList, out kwargsMatched, out defaultsNeeded))
                 {
                     continue;
diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -9,9 +9,11 @@ namespace Python.Runtime
 {
     internal static class OperatorMethod
     {
-        // Maps the compiled method name in .NET CIL (e.g. op_Addition) to
-        // the equivalent Python operator (e.g. __add__) as well as the offset
-        // that identifies that operator's slot (e.g. nb_add) in heap space.
+        /// <summary>
+        /// Maps the compiled method name in .NET CIL (e.g. op_Addition) to
+        /// the equivalent Python operator (e.g. __add__) as well as the offset
+        /// that identifies that operator's slot (e.g. nb_add) in heap space.
+        /// </summary>
         public static Dictionary<string, SlotDefinition> OpMethodMap { get; private set; }
         public readonly struct SlotDefinition
         {
@@ -27,6 +29,10 @@ public SlotDefinition(string methodName, int typeOffset)
 
         static OperatorMethod()
         {
+            // .NET operator method names are documented at:
+            // https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/operator-overloads
+            // Python operator methods and slots are documented at:
+            // https://docs.python.org/3/c-api/typeobj.html
             // TODO: Rich compare, inplace operator support
             OpMethodMap = new Dictionary<string, SlotDefinition>
             {

Original file line number	Diff line number	Diff line change
`@@ -21,13 +21,6 @@ public void Dispose()`
`21`	`21`	`PythonEngine.Shutdown();`
`22`	`22`	`}`
`23`	`23`
`24`		`- public class SampleClass`
`25`		`- {`
`26`		`- public int VoidCall() => 10;`
`27`		`-`
`28`		`- public int Foo(int a, int b = 10) => a + b;`
`29`		`- }`
`30`		`-`
`31`	`24`	`public class OperableObject`
`32`	`25`	`{`
`33`	`26`	`public int Num { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -9,9 +9,11 @@ namespace Python.Runtime`
`9`	`9`	`{`
`10`	`10`	`internal static class OperatorMethod`
`11`	`11`	`{`
`12`		`- // Maps the compiled method name in .NET CIL (e.g. op_Addition) to`
`13`		`- // the equivalent Python operator (e.g. __add__) as well as the offset`
`14`		`- // that identifies that operator's slot (e.g. nb_add) in heap space.`
	`12`	`+ /// <summary>`
	`13`	`+ /// Maps the compiled method name in .NET CIL (e.g. op_Addition) to`
	`14`	`+ /// the equivalent Python operator (e.g. __add__) as well as the offset`
	`15`	`+ /// that identifies that operator's slot (e.g. nb_add) in heap space.`
	`16`	`+ /// </summary>`
`15`	`17`	`public static Dictionary<string, SlotDefinition> OpMethodMap { get; private set; }`
`16`	`18`	`public readonly struct SlotDefinition`
`17`	`19`	`{`
`@@ -27,6 +29,10 @@ public SlotDefinition(string methodName, int typeOffset)`
`27`	`29`
`28`	`30`	`static OperatorMethod()`
`29`	`31`	`{`
	`32`	`+ // .NET operator method names are documented at:`
	`33`	`+ // https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/operator-overloads`
	`34`	`+ // Python operator methods and slots are documented at:`
	`35`	`+ // https://docs.python.org/3/c-api/typeobj.html`
`30`	`36`	`// TODO: Rich compare, inplace operator support`
`31`	`37`	`OpMethodMap = new Dictionary<string, SlotDefinition>`
`32`	`38`	`{`