Fix function compatibility (#1516)

* Fix function compatibility

* Fix test__ssl

* Fix comparisons

Author: slozier

Src/IronPython/Runtime/Binding/MetaPythonFunction.cs

@@ -365,11 +365,21 @@ private CallSignature Signature {
             /// Makes the test for our rule.
             /// </summary>
             private BindingRestrictions/*!*/ GetRestrictions() {
-                if (!Signature.HasKeywordArgument()) {
-                    return GetSimpleRestriction();
+                if (_extractedDefault) {
+                    return BindingRestrictions.GetInstanceRestriction(_func.Expression, _func.Value);
+                } else if (_needCodeTest) {
+                    return GetSimpleRestriction().Merge(
+                        BindingRestrictions.GetInstanceRestriction(
+                            Expression.Property(
+                                GetFunctionParam(),
+                                "__code__"
+                            ),
+                            _func.Value.__code__
+                        )
+                    );
                 }
 
-                return GetComplexRestriction();
+                return GetSimpleRestriction();
             }
 
             /// <summary>
@@ -389,28 +399,6 @@ private CallSignature Signature {
                 );
             }
 
-            /// <summary>
-            /// Makes the test when we have a keyword argument call or splatting.
-            /// </summary>
-            /// <returns></returns>
-            private BindingRestrictions/*!*/ GetComplexRestriction() {
-                if (_extractedDefault) {
-                    return BindingRestrictions.GetInstanceRestriction(_func.Expression, _func.Value);
-                } else if (_needCodeTest) {
-                    return GetSimpleRestriction().Merge(
-                        BindingRestrictions.GetInstanceRestriction(
-                            Expression.Property(
-                                GetFunctionParam(),
-                                "__code__"
-                            ),
-                            _func.Value.__code__
-                        )
-                    );
-                }
-
-                return GetSimpleRestriction();
-            }
-
             /// <summary>
             /// Gets the array of expressions which correspond to each argument for the function.  These
             /// correspond with the function as it's defined in Python and must be transformed for our
@@ -524,6 +512,8 @@ private bool FinishArguments(Expression[] exprArgs, List<Expression> paramsArgs,
 
                 var keywordOnlyArgumentCount = _func.Value.KeywordOnlyArgumentCount;
 
+                if (_func.Value.NeedsCodeTest) _needCodeTest = true;
+
                 for (int i = normalArgumentCount; i < normalArgumentCount + keywordOnlyArgumentCount; i++) {
                     var argName = _func.Value.ArgNames[i];
 

Src/IronPython/Runtime/PythonFunction.cs

@@ -33,6 +33,8 @@ public sealed partial class PythonFunction : PythonTypeSlot, IWeakReferenceable,
         public readonly MutableTuple Closure;
 
         private object[]/*!*/ _defaults;                // the default parameters of the method
+        private PythonDictionary _kwdefaults;           // the keyword-only arguments defaults for the method
+
         internal PythonDictionary _dict;                // a dictionary to story arbitrary members on the function object
         private object _module;                         // the module name
 
@@ -89,7 +91,7 @@ internal PythonFunction(CodeContext/*!*/ context, FunctionCode funcInfo, object
 
             _context = context;
             _defaults = defaults ?? ArrayUtils.EmptyObjects;
-            __kwdefaults__ = kwdefaults;
+            _kwdefaults = kwdefaults;
             _code = funcInfo;
             _doc = funcInfo._initialDoc;
             _name = funcInfo.co_name;
@@ -145,8 +147,13 @@ public PythonTuple __defaults__ {
             }
         }
 
-        // TODO: update CalculatedCachedCompat?
-        public PythonDictionary __kwdefaults__ { get; set; }
+        public PythonDictionary __kwdefaults__ {
+            get => _kwdefaults;
+            set {
+                _kwdefaults = value;
+                FunctionCompatibility = CalculatedCachedCompat();
+            }
+        }
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
         public object __closure__ {
@@ -277,6 +284,14 @@ internal string GetSignatureString() {
         /// </summary>
         internal int FunctionCompatibility { get; private set; }
 
+        internal bool NeedsCodeTest {
+            get {
+                return NormalArgumentCount > 0x3ff
+                    || Defaults.Length > 0x3ff
+                    || KeywordOnlyArgumentCount > 0x1ff;
+            }
+        }
+
         /// <summary>
         /// Calculates the _compat value which is used for call-compatibility checks
         /// for simple calls.  Whenver any of the dependent values are updated this
@@ -289,20 +304,20 @@ internal string GetSignatureString() {
         ///     expand dict/list - based on nparams and flags, both read-only
         ///     
         /// Bits are allocated as:
-        ///     000000ff - Normal argument count
-        ///     0000ff00 - Default count
-        ///     007f0000 - Keyword-only argument count
-        ///     3f800000 - Keyword-only defaults count
+        ///     000003ff - Normal argument count
+        ///     000ffc00 - Default count
+        ///     1ff00000 - Keyword-only argument count
+        ///     20000000 - has keyword-only defaults
         ///     40000000 - expand list
         ///     80000000 - expand dict
         ///     
         /// Enforce recursion is added at runtime.
         /// </summary>
         private int CalculatedCachedCompat() {
-            return (NormalArgumentCount) |
-                (Defaults.Length << 8) |
-                (KeywordOnlyArgumentCount << 16) |
-                ((__kwdefaults__?.Count ?? 0) << 23) |
+            return NormalArgumentCount |
+                (Defaults.Length << 10) |
+                (KeywordOnlyArgumentCount << 20) |
+                (__kwdefaults__ is not null ? 0x20000000 : 0) |
                 ((ExpandListPosition != -1) ? 0x40000000 : 0) |
                 ((ExpandDictPosition != -1) ? unchecked((int)0x80000000) : 0);
         }

Tests/modules/network_related/test__ssl.py

@@ -15,7 +15,7 @@
 from iptest import IronPythonTestCase, is_cli, is_netcoreapp, retryOnFailure, run_test, skipUnlessIronPython
 
 SSL_URL      = "www.python.org"
-SSL_ISSUER   = "CN=GlobalSign Atlas R3 DV TLS CA H2 2021, O=GlobalSign nv-sa, C=BE"
+SSL_ISSUER   = "CN=GlobalSign Atlas R3 DV TLS CA 2022 Q3, O=GlobalSign nv-sa, C=BE"
 SSL_SERVER   = "www.python.org"
 SSL_PORT     = 443
 SSL_REQUEST  = b"GET /en-us HTTP/1.0\r\nHost: www.python.org\r\n\r\n"

Tests/test_regressions.py

@@ -1683,4 +1683,22 @@ def __radd__(self, other):
             self.assertEqual(seq * m, 23)
             self.assertEqual(seq + m, 64)
 
+    def test_ipy3_gh1515(self):
+        # Because function compatibility for simple calls was defined as:
+        #   "number of args" + "number of defaults" << 8 + ...
+        # we got a conflict between 1 arg with default and 257 args.
+
+        # 1 arg with default
+        def d01(a=1): pass
+
+        d01(*(1,))
+
+        # 2.7 fails with 16385 args
+        # 3.4.0-beta fails with 257 args
+        for i in range(16):
+            size = (1<<i) + 1
+            d = {}
+            exec('def f(' + ','.join('a{0}'.format(i) for i in range(size)) + '): pass', d)
+            d["f"](*range(size)) # just make sure this runs successfully
+
 run_test(__name__)