printf style formatting: __getitem__ is the only condition to consider an object as a mapping

Author: steve-s

graalpython/com.oracle.graal.python.test/src/tests/test_formatting.py

@@ -53,6 +53,12 @@ def __bytes__(self):
         return b"bytes"
 
 
+# This is all one needs to implement to satisfy PyCheck_Mapping
+class MyPseudoMapping:
+    def __getitem__(self, item):
+        return item
+
+
 def test_formatting():
     # tests some corner-cases that the standard tests do not cover
     assert format(-12e8, "0=30,.4f") == '-0,000,000,001,200,000,000.0000'
@@ -74,6 +80,10 @@ def test_formatting():
     assert type(bytearray("hello %d", "ascii") % 42) == bytearray
     assert type(b"hello %d" % 42) == bytes
 
+    # No error about too many arguments,
+    # because the object is considered as a mapping...
+    assert " " % MyPseudoMapping() == " "
+
 
 def test_complex_formatting():
     assert format(3+2j, ">20,.4f") == "      3.0000+2.0000j"

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/formatting/BytesFormatProcessor.java

@@ -49,6 +49,7 @@
 import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 
+import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.bytes.BytesUtils;
 import com.oracle.graal.python.builtins.objects.bytes.PBytes;
@@ -115,6 +116,13 @@ protected double asFloat(Object arg) {
         }
     }
 
+    @Override
+    protected boolean useAsMapping(Object args1, PythonObjectLibrary lib, Object lazyClass) {
+        return !isString(args1, lazyClass) && isMapping(args1) && //
+                        !isSubtype(lazyClass, PythonBuiltinClassType.PBytes) && //
+                        !isSubtype(lazyClass, PythonBuiltinClassType.PByteArray);
+    }
+
     @Override
     protected Formatter handleSingleCharacterFormat(Spec spec) {
         // %c for bytes supports length one bytes buffer object (no __bytes__ coercion) or an

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/formatting/FormatProcessor.java

@@ -6,6 +6,7 @@
  */
 package com.oracle.graal.python.runtime.formatting;
 
+import static com.oracle.graal.python.nodes.SpecialMethodNames.__GETITEM__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__INDEX__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__INT__;
 import static com.oracle.graal.python.runtime.exception.PythonErrorType.MemoryError;
@@ -17,6 +18,7 @@
 import java.math.MathContext;
 
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
+import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.PythonAbstractObject;
 import com.oracle.graal.python.builtins.objects.floats.PFloat;
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
@@ -219,6 +221,24 @@ protected InternalFormat.Formatter formatInteger(Object intObj, InternalFormat.S
         return fi;
     }
 
+    /**
+     * Should this argument be treated as a mapping or as a single argument. This logic differs
+     * between string and bytes formatting.
+     */
+    protected abstract boolean useAsMapping(Object args1, PythonObjectLibrary lib, Object lazyClass);
+
+    protected boolean isString(Object args1, Object lazyClass) {
+        return PGuards.isString(args1) || isSubtype(lazyClass, PythonBuiltinClassType.PString);
+    }
+
+    protected boolean isMapping(Object args1) {
+        return lookupAttribute(args1, __GETITEM__) != PNone.NO_VALUE;
+    }
+
+    protected static boolean isSubtype(Object lazyClass, PythonBuiltinClassType clazz) {
+        return IsSubtypeNodeGen.getUncached().execute(lazyClass, clazz);
+    }
+
     /**
      * Main service of this class: format one or more arguments with the format string supplied at
      * construction.
@@ -238,15 +258,16 @@ private T formatImpl(Object args1) {
 
         // We need to do a full subtype-check because native objects may inherit from tuple but have
         // Java type 'PythonNativeObject' (e.g. 'namedtuple' alias 'structseq').
-        boolean tupleArgs = PGuards.isPTuple(args1) || IsSubtypeNodeGen.getUncached().execute(PythonObjectLibrary.getUncached().getLazyPythonClass(args1), PythonBuiltinClassType.PTuple);
-        assert tupleArgs || !PGuards.isPTuple(args1);
+        PythonObjectLibrary args1Lib = PythonObjectLibrary.getFactory().getUncached(args1);
+        final Object args1LazyClass = args1Lib.getLazyPythonClass(args1);
+        boolean tupleArgs = PGuards.isPTuple(args1) || isSubtype(args1LazyClass, PythonBuiltinClassType.PTuple);
         if (tupleArgs) {
             // We will simply work through the tuple elements
             argIndex = 0;
         } else {
             // Not a tuple, but possibly still some kind of container: use
             // special argIndex values.
-            if (!PGuards.isString(args1) && PythonObjectLibrary.getUncached().isMapping(args1)) {
+            if (useAsMapping(args1, args1Lib, args1LazyClass)) {
                 mapping = args1;
                 argIndex = -3;
             }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/formatting/StringFormatProcessor.java

@@ -15,6 +15,7 @@
 
 import com.oracle.graal.python.builtins.objects.PNone;
 import com.oracle.graal.python.builtins.objects.bytes.BytesUtils;
+import com.oracle.graal.python.builtins.objects.object.PythonObjectLibrary;
 import com.oracle.graal.python.builtins.objects.str.PString;
 import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.nodes.ErrorMessages;
@@ -61,6 +62,11 @@ Object parseMappingKey(int start, int end) {
         return formatText.substring(start, end);
     }
 
+    @Override
+    protected boolean useAsMapping(Object args1, PythonObjectLibrary lib, Object lazyClass) {
+        return !isString(args1, lazyClass) && isMapping(args1);
+    }
+
     @Override
     protected InternalFormat.Formatter handleSingleCharacterFormat(Spec spec) {
         InternalFormat.Formatter f;