format strings

- * PS > dist\bin\jython -S -c"from org.python.tests.mro import TortureMRO"
+ * An invocation at the prompt (for debugging use), and output before the fix, is: + * PS > dist\bin\jython -S -c"from org.python.tests.mro import EclipseChallengeMRO"
  * Traceback (most recent call last):
  *   File "<string>", line 1, in <module>
  * TypeError: Supertypes that share a modified attribute have an MRO
  * conflict[attribute=sort, supertypes=[<type 'java.util.List'>,
- * <type 'java.util.AbstractList'>], type=TortureMRO$Target]
+ * <type 'java.util.AbstractList'>], type=EclipseChallengeMRO$Target]
  * 
  */
-public class TortureMRO {
+public class EclipseChallengeMRO {
 
     interface Entry {} // Was FeatureMap.Entry
-
     interface Thing {} // Was EStructuralFeature.Setting
-
     interface EList extends java.util.List {}
-
     interface IEList extends EList {}
-
     interface FList extends EList {} // Was FeatureMap
-
     interface FIEListThing extends FList, IEList, Thing {}  // Was 2 FeatureMap.Internal
-
     abstract static class AbstractEList extends java.util.AbstractList implements EList {}
-
     abstract static class DEList extends AbstractEList {}
-
     interface NList extends EList {}
-
     abstract static class DNListImpl extends DEList implements NList {}
-
     abstract static class DNIEListImpl extends DNListImpl implements IEList {}
-
     abstract static class DNIEListThing extends DNIEListImpl implements Thing {}
-
     public abstract static class Target extends DNIEListThing implements FIEListThing {}
 }

diff --git a/tests/java/org/python/tests/mro/IBMMQChallengeMRO.java b/tests/java/org/python/tests/mro/IBMMQChallengeMRO.java
new file mode 100644
--- /dev/null
+++ b/tests/java/org/python/tests/mro/IBMMQChallengeMRO.java
@@ -0,0 +1,93 @@
+// Copyright (c)2019 Jython Developers.
+// Licensed to the Python Software Foundation under a Contributor Agreement.
+
+package org.python.tests.mro;
+
+import java.io.Serializable;
+import java.util.Map;
+
+/**
+ * A class providing interface and abstract class relationships that approximate the structure of
+ * com.ibm classes related to MQ, in order to exercise b.j.o issue 2445. The complex inheritance
+ * confused PyJavaType handling of the MRO. This class is imported by
+ * {@code test_java_integration.JavaMROTest.test_mro_ibmmq}.
+ * 
+ * An invocation at the prompt (for debugging use), and output before the fix, is: 
+ * PS > dist\bin\jython -S -c "from org.python.tests.mro import IBMMQChallengeMRO; t=m.mq.jms.MQQueue"
+ * Traceback (most recent call last):
+ *   File "<string>", line 1, in <module>
+ * TypeError: Supertypes that share a modified attribute have an MRO conflict
+ * [attribute=get,supertypes=[<type
+ * 'org.python.tests.mro.IBMMQChallengeMRO$msg$client$jms$internal$JmsPropertyContextImpl'>],
+ * type=IBMMQChallengeMRO$mq$jms$MQQueue]
+ * 
+ */
+public class IBMMQChallengeMRO {
+
+    static class javax_jms { // represents javax.jms
+
+        public interface Queue extends Destination {}
+        public interface Destination {}
+    }
+
+    static class javax_naming { // represents javax.naming
+
+        public interface Referenceable {}
+    }
+
+    static class msg { // represents com.ibm.msg
+
+        static class client { // represents com.ibm.msg.client
+
+            static class jms { // represents com.ibm.msg.client.jms
+
+                public interface JmsDestination extends JmsPropertyContext, javax_jms.Destination {}
+                public interface JmsPropertyContext
+                        extends JmsReadablePropertyContext, Map {}
+                public interface JmsReadablePropertyContext extends Serializable {}
+                public interface JmsQueue extends JmsDestination, javax_jms.Queue {}
+
+                static class admin { // represents com.ibm.msg.client.jms.admin
+
+                    public static abstract/* ? */ class JmsJndiDestinationImpl
+                            extends JmsDestinationImpl
+                            implements JmsDestination, javax_naming.Referenceable, Serializable {}
+                    public static abstract/* ? */ class JmsDestinationImpl
+                            extends internal.JmsPropertyContextImpl implements JmsDestination {}
+                }
+
+                static class internal { // represents com.ibm.msg.client.jms.internal
+
+                    public static abstract/* ? */ class JmsPropertyContextImpl
+                            extends JmsReadablePropertyContextImpl implements JmsPropertyContext,
+                            provider.ProviderPropertyContextCallback {}
+                    public static abstract class JmsReadablePropertyContextImpl
+                            implements JmsReadablePropertyContext {}
+                }
+            }
+
+            static class provider { // represents com.ibm.msg.client.provider
+
+                public interface ProviderPropertyContextCallback {}
+            }
+        }
+    }
+
+    static class jms { // represents com.ibm.jms
+
+        public interface JMSDestination extends javax_jms.Destination {}
+    }
+
+    public static class mq { // represents com.ibm.mq
+
+        public static class jms { // represents com.ibm.mq.jms
+
+            public abstract/* ? */ class MQDestination
+                    extends msg.client.jms.admin.JmsJndiDestinationImpl implements
+                    javax_jms.Destination, IBMMQChallengeMRO.jms.JMSDestination, Serializable {}
+            /** Target class in the test **/
+            public abstract/* ? */ class MQQueue extends MQDestination implements javax_jms.Queue,
+                    msg.client.jms.JmsQueue, javax_naming.Referenceable, Serializable {}
+        }
+    }
+}

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sun Apr 28 12:03:43 2019
From: jython-checkins at python.org (jeff.allen)
Date: Sun, 28 Apr 2019 16:03:43 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Return_Java_super-class_to?=
 =?utf-8?q?_first_position_in_type=2E=5F=5Fbases=5F=5F=2E_Fixes_bjo_=23244?=
 =?utf-8?q?5=2E?=
Message-ID: <20190428160343.1.ECF5F93B877A87D5@mg.python.org>

https://hg.python.org/jython/rev/36db7416b3b7
changeset:   8239:36db7416b3b7
user:        Jeff Allen 
date:        Sun Apr 28 14:27:43 2019 +0100
summary:
  Return Java super-class to first position in type.__bases__. Fixes bjo #2445.

The precedence of additions to the proxy types for java.util.List, etc. is
sensitive to the MRO of proxies for Java classes implementing those interfaces.
As initially implemented, this motivated moving the super-class to final
position in type.__bases__, contrary to Java inheritance rles, and this caused
problems in the proxies of classes with complex inheritance. The change here
has us pay greater respect to Java inheritance, having found the placing last
only to be necessary when the (nominal) super-class is java.lang.Object.

This is done with minimal change to the apparatus of proxies and handleMroError,
although close examination during the investigation suggested a number of
improvements peripheral to the fix.

files:
  Lib/test/test_java_integration.py   |  25 +++----
  NEWS                                |   2 +-
  src/org/python/core/Deriveds.java   |  10 +-
  src/org/python/core/PyJavaType.java |  52 +++++++++++++---
  4 files changed, 58 insertions(+), 31 deletions(-)


diff --git a/Lib/test/test_java_integration.py b/Lib/test/test_java_integration.py
--- a/Lib/test/test_java_integration.py
+++ b/Lib/test/test_java_integration.py
@@ -557,18 +557,18 @@
         self.assertRaises(TypeError, GetitemAdder.addPostdefined)
 
     def test_diamond_inheritance_of_iterable_and_map(self):
-        """Test deeply nested diamond inheritance of Iterable and Map, as see in some Clojure classes"""
-        # http://bugs.jython.org/issue1878
-        from javatests import DiamondIterableMapMRO  # this will raise a TypeError re MRO conflict without the fix
-        # Verify the correct MRO is generated - order is of course *important*;
-        # the following used types are implemented as empty interfaces/abstract classes, but match the inheritance graph
-        # and naming of Clojure/Storm.
-        #
-        # Also instead of directly importing, which would cause annoying bloat in javatests by making lots of little files,
-        # just match using str - this will still be stable/robust.
-        self.assertEqual(
-            str(DiamondIterableMapMRO.__mro__),
-            "(, , , , , , , , , , , , , , )")
+        """Test deeply nested diamond inheritance of Iterable and Map"""
+        # http://bugs.jython.org/issue1878. Previously raised a TypeError (MRO conflict).
+        from javatests import DiamondIterableMapMRO
+        # The MRO places Iterable ahead of Map (so that __iter__ means j.u.Iterator.__iter__).
+        # The following used types are empty interfaces and abstract classes matching the 
+        # inheritance graph and naming of Clojure/Storm, where the bug was discovered.
+        # Match using str - this will still be stable/robust.
+        mrostr = str(DiamondIterableMapMRO.__mro__)
+        jli = mrostr.find("java.lang.Iterable")
+        self.assertGreater(jli, -1, "Iterable must be in the MRO")
+        jum = mrostr.find("java.util.Map")
+        self.assertGreater(jum, jli, "Map must come later than Iterable")
         # And usable with __iter__ and map functionality
         m = DiamondIterableMapMRO()
         m["abc"] = 42
@@ -580,7 +580,6 @@
         # http://bugs.jython.org/issue2445
         from org.python.tests.mro import EclipseChallengeMRO
 
-    @unittest.skip("FIXME: see http://bugs.jython.org/issue2445")
     def test_mro_ibmmq(self):
         # http://bugs.jython.org/issue2445
         from org.python.tests.mro import IBMMQChallengeMRO
diff --git a/NEWS b/NEWS
--- a/NEWS
+++ b/NEWS
@@ -5,11 +5,11 @@
 
 Development tip
   Bugs fixed
+    - [ 2445 ] Eclipse's DelegatingFeatureMap has MRO conflict (and IBM's MQQueue)
     - [ GH-121 ] Allow struct unpack and unpack_from bytearray and buffer
     - [ 2635 ] AST.lineno ignored by compile
     - [ 2744 ] Support buffer type in marshal.dump(s)
     - [ 2077 ] marshal doesn't raise error when fed unmarshalable object
-    - [ 2445 ] Eclipse's DelegatingFeatureMap has MRO conflict
     - [ 2732 ] Regression in large module support for pip
     - [ GH-131 ] Support Unicode in zxJDBC exceptions.
     - [ 2654 ] Imported modules allow access to submodules
diff --git a/src/org/python/core/Deriveds.java b/src/org/python/core/Deriveds.java
--- a/src/org/python/core/Deriveds.java
+++ b/src/org/python/core/Deriveds.java
@@ -1,4 +1,5 @@
-/* Copyright (c) Jython Developers */
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
 /**
@@ -47,10 +48,9 @@
             } else {
                 PyObject getattribute = type.lookup("__getattribute__");
                 if (getattribute == null) {
-                    // This shouldn't happen
-                    throw Py.SystemError(String.format(
-                            "__getattribute__ not found on type %s. See http://bugs.jython.org/issue2487 for details.",
-                            type.getName()));
+                    // This shouldn't happen (and isn't always to do with bjo #2487 when it does).
+                    throw Py.SystemError(
+                            String.format("__getattribute__ not found on type %s", type.getName()));
                 }
                 if (getattribute == objectGetattribute) {
                     type.setUsesObjectGetattribute(true);
diff --git a/src/org/python/core/PyJavaType.java b/src/org/python/core/PyJavaType.java
--- a/src/org/python/core/PyJavaType.java
+++ b/src/org/python/core/PyJavaType.java
@@ -38,6 +38,7 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Queue;
 import java.util.Set;
 import java.util.Stack;
@@ -262,7 +263,7 @@
                         /*
                          * The method name was already in the set, so has appeared already. Work out
                          * which one that was by rescanning.
-                         */// XXX Why didn't we keep a map?
+                         */
                         List types = new ArrayList<>();
                         Set> proxySet = new HashSet<>();
                         Class proxyType = type.getProxyType();
@@ -288,15 +289,27 @@
                         }
 
                         /*
-                         * Need to special case collections that implement both Iterable and Map.
-                         * Ignore the conflict in having duplicate __iter__ added (see
-                         * getCollectionProxies), while still allowing each path on the inheritance
-                         * hierarchy to get an __iter__. Annoying but necessary logic. See
-                         * http://bugs.jython.org/issue1878
+                         * Need to special case __iter__ in certain circumstances to ignore the
+                         * conflict in having duplicate __iter__ added (see getCollectionProxies),
+                         * while still allowing each path on the inheritance hierarchy to get an
+                         * __iter__. Annoying but necessary logic.
                          */
-                        if (method.equals("__iter__")
-                                && Generic.set(Iterable.class, Map.class).containsAll(proxySet)) {
-                            continue;
+                        if (method.equals("__iter__")) {
+                            if (Generic.set(Iterable.class, Map.class).containsAll(proxySet)) {
+                                /*
+                                 * Need to special case __iter__ in collections that implement both
+                                 * Iterable and Map. See http://bugs.jython.org/issue1878
+                                 */
+                                continue;
+                            } else if (Generic.set(Iterator.class, Enumeration.class)
+                                    .containsAll(proxySet)) {
+                                /*
+                                 * Need to special case __iter__ in iterators that Iterator and
+                                 * Enumeration. Annoying but necessary logic. See
+                                 * http://bugs.jython.org/issue2445
+                                 */
+                                continue;
+                            }
                         }
 
                         String fmt = "Supertypes that share a modified attribute "
@@ -381,7 +394,7 @@
              * superclass.
              */
             needsInners.add(this);
-            List visibleBases = Generic.list();
+            LinkedList visibleBases = new LinkedList<>();
             for (Class iface : forClass.getInterfaces()) {
                 if (iface == PyProxy.class || iface == ClassDictInit.class) {
                     /*
@@ -405,13 +418,27 @@
             if (forClass == Object.class) {
                 base = Constant.PYOBJECT;
             } else if (baseClass == null) {
+                /*
+                 * It would be most like Java to have no base (like PyNone) but in that case, the
+                 * MRO calculation puts Object ahead of the interface. Our patching of Java
+                 * container interfaces to behave like Python container objects requires the
+                 * opposite.
+                 */
                 base = Constant.OBJECT;
             } else if (forClass == Class.class) {
                 base = Constant.PYTYPE;
             } else {
                 base = fromClass(baseClass);
             }
-            visibleBases.add(base);
+
+            if (baseClass == null) {
+                // Object, an interface, a primitive or void: base goes last.
+                visibleBases.add(base);
+            } else {
+                // forClass represents a (concrete or abstract) class: base comes before interfaces.
+                visibleBases.push(base);
+            }
+
             this.bases = visibleBases.toArray(new PyObject[visibleBases.size()]);
             mro = computeMro();
         }
@@ -467,10 +494,11 @@
                 }
             }
         }
+
         // Methods must be in resolution order. See issue bjo #2391 for detail.
         Arrays.sort(methods, new MethodComparator(new ClassComparator()));
 
-        /* Add methods, also accumulating them in reflectedFuncs, and spotting Java Bean members. */
+        // Add methods, also accumulating them in reflectedFuncs, and spotting Java Bean members.
         ArrayList reflectedFuncs = new ArrayList<>(methods.length);
         Map props = Generic.map();
         Map> events = Generic.map();

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Sun Apr 28 12:03:43 2019
From: jython-checkins at python.org (jeff.allen)
Date: Sun, 28 Apr 2019 16:03:43 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_=28Trivial=29_documentatio?=
 =?utf-8?q?n_additions_and_code_clarity_around_PyJavaType=2Ejava=2E?=
Message-ID: <20190428160343.1.B8FEAA6208E232D4@mg.python.org>

https://hg.python.org/jython/rev/e233f3fc6fde
changeset:   8238:e233f3fc6fde
user:        Jeff Allen 
date:        Mon Apr 22 10:50:32 2019 +0100
summary:
  (Trivial) documentation additions and code clarity around PyJavaType.java.

files:
  src/org/python/core/PyJavaType.java             |  43 ++++++--
  src/org/python/core/PyMethodDescr.java          |   8 +-
  src/org/python/core/PyReflectedConstructor.java |  27 +++--
  src/org/python/core/PyReflectedFunction.java    |   8 +-
  src/org/python/core/ReflectedArgs.java          |  48 +++++----
  5 files changed, 87 insertions(+), 47 deletions(-)


diff --git a/src/org/python/core/PyJavaType.java b/src/org/python/core/PyJavaType.java
--- a/src/org/python/core/PyJavaType.java
+++ b/src/org/python/core/PyJavaType.java
@@ -1,3 +1,5 @@
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
 import org.python.core.util.StringUtil;
@@ -465,14 +467,17 @@
                 }
             }
         }
-        // Methods must be in resolution order. See issue #2391 for detail.
+        // Methods must be in resolution order. See issue bjo #2391 for detail.
         Arrays.sort(methods, new MethodComparator(new ClassComparator()));
 
-        // Add methods, also accumulating them in reflectedFuncs, and spotting Java Bean members.
+        /* Add methods, also accumulating them in reflectedFuncs, and spotting Java Bean members. */
         ArrayList reflectedFuncs = new ArrayList<>(methods.length);
         Map props = Generic.map();
         Map> events = Generic.map();
+
+        // First pass skip inherited (and certain "ignored") methods.
         addMethods(baseClass, reflectedFuncs, props, events, methods);
+        // Add inherited and previously ignored methods
         addInheritedMethods(reflectedFuncs, methods);
 
         // Add fields declared on this type
@@ -625,10 +630,11 @@
     }
 
     /**
-     * Process the given class for methods defined on the target class itself (the
-     * fromClass), rather than inherited.
-     *
-     * This is exclusively a helper method for {@link #init(Set)}.
+     * Add descriptors to this type's dictionary ({@code __dict__}) for methods defined on the
+     * target class itself (the {@code fromClass}), where not inherited. One descriptor is created
+     * for each simple name and a signature for every method with that simple name is added to the
+     * descriptor. See also {@link #addInheritedMethods(List, Method[])}. This is exclusively a
+     * helper method for {@link #init(Set)}.
      *
      * @param baseClass ancestor of the target class
      * @param reflectedFuncs to which reflected functions are added for further processing
@@ -642,7 +648,6 @@
 
         boolean isInAwt = name.startsWith("java.awt.") && name.indexOf('.', 9) == -1;
 
-        // First pass skip inherited (and certain "ignored") methods.
         for (Method meth : methods) {
             if (!declaredHere(baseClass, meth) || ignore(meth)) {
                 continue;
@@ -663,10 +668,12 @@
 
             PyReflectedFunction reflfunc = (PyReflectedFunction) dict.__finditem__(nmethname);
             if (reflfunc == null) {
+                // A new descriptor is required
                 reflfunc = new PyReflectedFunction(meth);
                 reflectedFuncs.add(reflfunc);
                 dict.__setitem__(nmethname, reflfunc);
             } else {
+                // A descriptor for the same simple name exists: add a signature to it.
                 reflfunc.addMethod(meth);
             }
 
@@ -752,15 +759,29 @@
     }
 
     /**
-     * Process the given class for methods inherited from ancestor classes.
-     *
-     * This is exclusively a helper method for {@link #init(Set)}.
+     * Add descriptors to this type's dictionary ({@code __dict__}) for methods inherited from
+     * ancestor classes. This is exclusively a helper method for {@link #init(Set)}.
+     * 
+     * Python finds an inherited method by looking in the dictionaries of types along the MRO. This
+     * is does not directly emulate the signature polymorphism of Java. Even though the entries of
+     * the MRO include the {@code PyType}s of the Java ancestors of this class, each type's
+     * dictionary is keyed on the simple name of the method. For the present class, and at the point
+     * where this method is called, any method defined on this class has created a descriptor entry
+     * for that method name (see {@link #addMethods(Class, List, Map, Map, Method[])}), but only for
+     * the signatures defined directly in this class. If any method of the same simple name is
+     * inherited in Java from a super-class, it is now shadowed by this entry as far as Python is
+     * concerned. The purpose of this method is to add the shadowed method signatures.
+     * 

+     * For example {@code AbstractCollection} defines {@code add(E)}, and {@code AbstractList}
+     * inherits it but also defines {@code add(int, E)} (giving control of the insertion point).
+     * When {@link #addMethods(Class, List, Map, Map, Method[])} completes, the "add" descriptor in
+     * {@code type(AbstractList)}, represents only {@code add(int, E)}, and we must add the
+     * inherited signature for {@code add(E)}.
      *
      * @param reflectedFuncs to which reflected functions are added for further processing
      * @param methods of the target class
      */
     private void addInheritedMethods(List reflectedFuncs, Method[] methods) {
-        // Add inherited and previously ignored methods
         for (Method meth : methods) {
             String nmethname = normalize(meth.getName());
             PyReflectedFunction reflfunc = (PyReflectedFunction) dict.__finditem__(nmethname);
diff --git a/src/org/python/core/PyMethodDescr.java b/src/org/python/core/PyMethodDescr.java
--- a/src/org/python/core/PyMethodDescr.java
+++ b/src/org/python/core/PyMethodDescr.java
@@ -1,3 +1,5 @@
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
 import org.python.expose.ExposedGet;
@@ -17,7 +19,7 @@
         minargs = func.info.getMinargs();
         maxargs = func.info.getMaxargs();
         meth = func;
-        meth.setInfo(this);
+        meth.setInfo(this); // XXX Why modify func.info each time used?
     }
 
     @ExposedGet(name = "__doc__")
@@ -25,10 +27,12 @@
         return meth.getDoc();
     }
 
+    @Override
     public int getMaxargs() {
         return maxargs;
     }
 
+    @Override
     public int getMinargs() {
         return minargs;
     }
@@ -54,6 +58,7 @@
         return meth.bind(args[0]).__call__(actualArgs, kwargs);
     }
 
+    @Override
     public PyException unexpectedCall(int nargs, boolean keywords) {
         return PyBuiltinCallable.DefaultInfo.unexpectedCall(nargs, keywords, name, minargs,
                                                             maxargs);
@@ -78,6 +83,7 @@
      *
      * @return a name String
      */
+    @Override
     @ExposedGet(name = "__name__")
     public String getName() {
         return name;
diff --git a/src/org/python/core/PyReflectedConstructor.java b/src/org/python/core/PyReflectedConstructor.java
--- a/src/org/python/core/PyReflectedConstructor.java
+++ b/src/org/python/core/PyReflectedConstructor.java
@@ -1,4 +1,6 @@
 // Copyright (c) Corporation for National Research Initiatives
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
 import java.lang.reflect.Constructor;
@@ -40,7 +42,7 @@
         // Check for a matching constructor to call
         if (nargs > 0) { // PyArgsKeywordsCall signature, if present, is the first
             if (argslist[0].matches(null, args, keywords, callData)) {
-                method = argslist[0].data;
+                method = argslist[0].method;
                 consumes_keywords = argslist[0].flags == ReflectedArgs.PyArgsKeywordsCall;
             } else {
                 allArgs = args;
@@ -52,7 +54,7 @@
                 }
                 for (; i < nargs; i++) {
                     if (argslist[i].matches(null, args, Py.NoKeywords, callData)) {
-                        method = argslist[i].data;
+                        method = argslist[i].method;
                         break;
                     }
                 }
@@ -116,7 +118,7 @@
         }
         ReflectedCallData callData = new ReflectedCallData();
         Object method = null;
-        
+
         // If we have keyword args, there are two ways this can be handled;
         // a) we find a constructor that takes keyword args, and use it.
         // b) we don't, in which case we strip the keyword args, and pass the
@@ -129,25 +131,25 @@
         boolean usingKeywordArgsCtor = false;
         if (nkeywords > 0) {
             // We have keyword args.
-            
+
             // Look for a constructor; the ReflectedArgs#matches() method exits early in the case
             // where keyword args are used
             int n = nargs;
             for (int i = 0; i < n; i++) {
                 rargs = argslist[i];
                 if (rargs.matches(null, args, keywords, callData)) {
-                    method = rargs.data;
+                    method = rargs.method;
                     break;
                 }
             }
-            
+
             if (method != null) {
                 // Constructor found that will accept the keyword args
                 usingKeywordArgsCtor = true;
             } else {
                 // No constructor found that will take keyword args
-                
-                // Remove the keyword args  
+
+                // Remove the keyword args
                 args = new PyObject[allArgs.length - nkeywords];
                 System.arraycopy(allArgs, 0, args, 0, args.length);
 
@@ -155,7 +157,7 @@
                 for (int i = 0; i < n; i++) {
                     rargs = argslist[i];
                     if (rargs.matches(null, args, Py.NoKeywords, callData)) {
-                        method = rargs.data;
+                        method = rargs.method;
                         break;
                     }
                 }
@@ -166,12 +168,12 @@
            for (int i = 0; i < n; i++) {
                rargs = argslist[i];
                if (rargs.matches(null, args, Py.NoKeywords, callData)) {
-                   method = rargs.data;
+                   method = rargs.method;
                    break;
                }
            }
        }
-        
+
         // Throw an error if no valid set of arguments
         if (method == null) {
             throwError(callData.errArg, args.length, false, false);
@@ -217,8 +219,9 @@
                         msg += " " + sup.getName();
                     }
                     throw Py.TypeError(msg);
-                } else
+                } else {
                     throw Py.JavaError(e);
+                }
             } catch (Throwable t) {
                 throw Py.JavaError(t);
             }
diff --git a/src/org/python/core/PyReflectedFunction.java b/src/org/python/core/PyReflectedFunction.java
--- a/src/org/python/core/PyReflectedFunction.java
+++ b/src/org/python/core/PyReflectedFunction.java
@@ -1,4 +1,6 @@
 // Copyright (c) Corporation for National Research Initiatives
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
 import java.lang.reflect.Method;
@@ -169,7 +171,7 @@
             throwError(callData.errArg, args.length, self != null, keywords.length != 0);
         }
         Object cself = callData.self;
-        Method m = (Method)match.data;
+        Method m = (Method)match.method;
 
         // If this is a direct call to a Java class instance method with a PyProxy instance as the
         // arg, use the super__ version to actually route this through the method on the class.
@@ -344,7 +346,9 @@
     public int traverse(Visitproc visit, Object arg) {
         if (__module__ != null) {
             int res = visit.visit(__module__, arg);
-            if (res != 0) return res;
+            if (res != 0) {
+                return res;
+            }
         }
         return __doc__ != null ? visit.visit(__doc__, arg) : 0;
     }
diff --git a/src/org/python/core/ReflectedArgs.java b/src/org/python/core/ReflectedArgs.java
--- a/src/org/python/core/ReflectedArgs.java
+++ b/src/org/python/core/ReflectedArgs.java
@@ -1,10 +1,18 @@
 // Copyright (c) Corporation for National Research Initiatives
+// Copyright (c)2019 Jython Developers.
+// Licensed to PSF under a Contributor Agreement.
 package org.python.core;
 
+import java.lang.reflect.Member;
+
+/** Map the signature of a method to the {@code Method} itself, within the context of a given simple name. This is used in support of signature polymorphism in Java methods and constructors reflected into Python. **/
 public class ReflectedArgs {
+
+    /** The types of arguments defining this signature (key) */
     public Class[] args;
 
-    public Object data;
+    /** The specific method (or constructor). */
+    public Member method;
 
     public Class declaringClass;
 
@@ -20,21 +28,21 @@
 
     public static final int PyArgsKeywordsCall = 2;
 
-    public ReflectedArgs(Object data, Class[] args, Class declaringClass, boolean isStatic) {
-        this(data, args, declaringClass, isStatic, false);
+    public ReflectedArgs(Member method, Class[] args, Class declaringClass, boolean isStatic) {
+        this(method, args, declaringClass, isStatic, false);
     }
 
-    public ReflectedArgs(Object data, Class[] args, Class declaringClass, boolean isStatic, boolean isVarArgs) {
-        this.data = data;
+    public ReflectedArgs(Member method, Class[] args, Class declaringClass, boolean isStatic,
+            boolean isVarArgs) {
+        this.method = method;
         this.args = args;
         this.declaringClass = declaringClass;
         this.isStatic = isStatic;
-        this.isVarArgs = isVarArgs; // only used for varargs matching; it should be added after the unboxed form
-
+        // only used for varargs matching; it should be added after the unboxed form
+        this.isVarArgs = isVarArgs;
         if (args.length == 1 && args[0] == PyObject[].class) {
             this.flags = PyArgsCall;
-        } else if (args.length == 2 && args[0] == PyObject[].class
-                && args[1] == String[].class) {
+        } else if (args.length == 2 && args[0] == PyObject[].class && args[1] == String[].class) {
             this.flags = PyArgsKeywordsCall;
         } else {
             this.flags = StandardCall;
@@ -52,8 +60,8 @@
         // if (isStatic ? self != null : self == null) return Py.NoConversion;
         /* Ugly code to handle mismatch in static vs. instance functions... */
         /*
-         * Will be very inefficient in cases where static and instance functions
-         * both exist with same names and number of args
+         * Will be very inefficient in cases where static and instance functions both exist with
+         * same names and number of args
          */
         if (this.isStatic) {
             if (self != null) {
@@ -136,7 +144,7 @@
 
         for (int i = 0; i < n; i++) {
             PyObject pyArg = pyArgs[i];
-            Class targetClass = this.args[i];
+            Class targetClass = this.args[i];
             Object javaArg = pyArg.__tojava__(targetClass);
             javaArgs[i] = javaArg;
             if (javaArg == Py.NoConversion) {
@@ -153,13 +161,11 @@
     private PyObject[] ensureBoxedVarargs(PyObject[] pyArgs, int n) {
         if (pyArgs.length == 0) {
             // If there are no args return an empty list
-            return new PyObject[]{new PyList()};
+            return new PyObject[] {new PyList()};
         }
         PyObject lastArg = pyArgs[pyArgs.length - 1];
-        if (lastArg instanceof PySequenceList ||
-                lastArg instanceof PyArray ||
-                lastArg instanceof PyXRange ||
-                lastArg instanceof PyIterator) {
+        if (lastArg instanceof PySequenceList || lastArg instanceof PyArray
+                || lastArg instanceof PyXRange || lastArg instanceof PyIterator) {
             // NOTE that the check is against PySequenceList, not PySequence,
             // because certain Java <=> Python semantics currently require this
             // additional strictness. Perhaps this can be relaxed.
@@ -236,9 +242,8 @@
     }
 
     /*
-     * Returns 0 iff arg1 == arg2 Returns +/-1 iff arg1 and arg2 are
-     * unimportantly different Returns +/-2 iff arg1 and arg2 are significantly
-     * different
+     * Returns 0 iff arg1 == arg2 Returns +/-1 iff arg1 and arg2 are unimportantly different Returns
+     * +/-2 iff arg1 and arg2 are significantly different
      */
     public static int compare(Class arg1, Class arg2) {
         int p1 = precedence(arg1);
@@ -320,7 +325,8 @@
 
     @Override
     public String toString() {
-        String s =  declaringClass + ", static=" + isStatic + ", varargs=" + isVarArgs + ",flags=" + flags + ", " + data + "\n";
+        String s = declaringClass + ", static=" + isStatic + ", varargs=" + isVarArgs + ",flags="
+                + flags + ", " + method + "\n";
         s = s + "\t(";
         for (Class arg : args) {
             s += arg.getName() + ", ";

-- 
Repository URL: https://hg.python.org/jython

From jython-checkins at python.org  Mon Apr 29 14:20:19 2019
From: jython-checkins at python.org (jeff.allen)
Date: Mon, 29 Apr 2019 18:20:19 +0000
Subject: [Jython-checkins] =?utf-8?q?jython=3A_Close_underlying_file_in_F?=
 =?utf-8?q?ileIO=2Eclose=2C_even_on_error=2E?=
Message-ID: <20190429182019.1.8AEF7A5F44DAA645@mg.python.org>

https://hg.python.org/jython/rev/c8ee321409c2
changeset:   8240:c8ee321409c2
user:        Jeff Allen 
date:        Mon Apr 29 07:25:09 2019 +0100
summary:
  Close underlying file in FileIO.close, even on error.

And some other bugs in tests that leave files open.

files:
  Lib/test/test_io.py                      |   2 +
  Lib/test/test_java_integration.py        |   3 +-
  src/org/python/modules/_io/PyFileIO.java |  19 ++++++-----
  3 files changed, 15 insertions(+), 9 deletions(-)


diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -2203,6 +2203,7 @@
         self.assertEqual(s, prefix.decode("ascii"))
         self.assertEqual(f.tell(), prefix_size)
         self.assertEqual(f.readline(), u_suffix)
+        f.close()
 
     def test_seeking_too(self):
         # Regression test for a specific bug
@@ -2215,6 +2216,7 @@
         f._CHUNK_SIZE = 2
         f.readline()
         f.tell()
+        f.close()
 
     def test_seek_and_tell(self):
         #Test seek/tell using the StatefulIncrementalDecoder.
diff --git a/Lib/test/test_java_integration.py b/Lib/test/test_java_integration.py
--- a/Lib/test/test_java_integration.py
+++ b/Lib/test/test_java_integration.py
@@ -117,7 +117,7 @@
 
     def test_awt_hack(self):
         # We ignore several deprecated methods in java.awt.* in favor of bean properties that were
-        # addded in Java 1.1.  This tests that one of those bean properties is visible.
+        # added in Java 1.1.  This tests that one of those bean properties is visible.
         c = Container()
         c.size = 400, 300
         self.assertEquals(Dimension(400, 300), c.size)
@@ -128,6 +128,7 @@
 
     def tearDown(self):
         sys.stdout = self.orig_stdout
+        test_support.unlink(test_support.TESTFN)
 
     def test_stdout_outputstream(self):
         out = FileOutputStream(test_support.TESTFN)
diff --git a/src/org/python/modules/_io/PyFileIO.java b/src/org/python/modules/_io/PyFileIO.java
--- a/src/org/python/modules/_io/PyFileIO.java
+++ b/src/org/python/modules/_io/PyFileIO.java
@@ -360,15 +360,18 @@
 
     @ExposedMethod
     final synchronized void FileIO_close() {
-        // Close this object to further input (also calls flush)
-        super.close();
-        // Now close downstream (if required to)
-        if (closefd) {
-            ioDelegate.close();
+        try {
+            // Close this object to further input (also calls flush)
+            super.close();
+        } finally {
+            // Now close downstream (if required to)
+            if (closefd) {
+                ioDelegate.close();
+            }
+            // This saves us doing two tests for each action (when the file is open)
+            readable = false;
+            writable = false;
         }
-        // This saves us doing two tests for each action (when the file is open)
-        readable = false;
-        writable = false;
     }
 
     @Override

-- 
Repository URL: https://hg.python.org/jython

