Use PyTuple nodes during string formatting as CPython does

Author: timfel

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

@@ -0,0 +1,42 @@
+# Copyright (c) 2025, 2025, Oracle and/or its affiliates. All rights reserved.
+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+#
+# The Universal Permissive License (UPL), Version 1.0
+#
+# Subject to the condition set forth below, permission is hereby granted to any
+# person obtaining a copy of this software, associated documentation and/or
+# data (collectively the "Software"), free of charge and under any and all
+# copyright rights in the Software, and any and all patent rights owned or
+# freely licensable by each licensor hereunder covering either (i) the
+# unmodified Software as contributed to or provided by such licensor, or (ii)
+# the Larger Works (as defined below), to deal in both
+#
+# (a) the Software, and
+#
+# (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+# one is included with the Software each a "Larger Work" to which the Software
+# is contributed by such licensors),
+#
+# without restriction, including without limitation the rights to copy, create
+# derivative works of, display, perform, and distribute the Software and make,
+# use, sell, offer for sale, import, export, have made, and have sold the
+# Software and the Larger Work(s), and to sublicense the foregoing rights on
+# either these or other terms.
+#
+# This license is subject to the following condition:
+#
+# The above copyright notice and either this complete permission notice or at a
+# minimum a reference to the UPL must be included in all copies or substantial
+# portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+def test_platform_uname():
+    import platform
+    assert repr(platform.uname()), "should not raise"

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/bytes/BytesCommonBuiltins.java

@@ -96,7 +96,6 @@
 import com.oracle.graal.python.builtins.objects.iterator.PSequenceIterator;
 import com.oracle.graal.python.builtins.objects.list.PList;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
-import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.builtins.objects.type.TpSlots;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotBinaryFunc.SqConcatBuiltinNode;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotBinaryOp.BinaryOpBuiltinNode;
@@ -356,13 +355,12 @@ static Object mod(VirtualFrame frame, Object self, Object right,
                         @Cached("createFor(this)") IndirectCallData indirectCallData,
                         @CachedLibrary(limit = "3") PythonBufferAcquireLibrary acquireLib,
                         @CachedLibrary(limit = "3") PythonBufferAccessLibrary bufferLib,
-                        @Cached BytesNodes.CreateBytesNode create,
-                        @Cached TupleBuiltins.GetItemNode getTupleItemNode) {
+                        @Cached BytesNodes.CreateBytesNode create) {
             Object buffer = acquireLib.acquireReadonly(self, frame, indirectCallData);
             try {
                 byte[] bytes = bufferLib.getInternalOrCopiedByteArray(buffer);
                 int bytesLen = bufferLib.getBufferLength(buffer);
-                BytesFormatProcessor formatter = new BytesFormatProcessor(PythonContext.get(inliningTarget), getTupleItemNode, bytes, bytesLen, inliningTarget);
+                BytesFormatProcessor formatter = new BytesFormatProcessor(PythonContext.get(inliningTarget), bytes, bytesLen, inliningTarget);
                 Object savedState = IndirectCallContext.enter(frame, inliningTarget, indirectCallData);
                 try {
                     byte[] data = formatter.format(right);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/str/StringBuiltins.java

@@ -117,7 +117,6 @@
 import com.oracle.graal.python.builtins.objects.str.StringNodes.StringReplaceNode;
 import com.oracle.graal.python.builtins.objects.str.StringUtils.StripKind;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
-import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.builtins.objects.type.TpSlots;
 import com.oracle.graal.python.builtins.objects.type.TypeNodes;
 import com.oracle.graal.python.builtins.objects.type.slots.TpSlotBinaryFunc.MpSubscriptBuiltinNode;
@@ -1871,14 +1870,13 @@ static Object doGeneric(VirtualFrame frame, Object self, Object right,
                         @SuppressWarnings("unused") @Cached PyUnicodeCheckNode check,
                         @Cached("createFor(this)") IndirectCallData indirectCallData,
                         @Cached CastToJavaStringCheckedNode castSelfNode,
-                        @Cached TupleBuiltins.GetItemNode getTupleItemNode,
                         @Cached TruffleString.FromJavaStringNode fromJavaStringNode) {
             String selfStr = castSelfNode.cast(inliningTarget, self, ErrorMessages.REQUIRES_STR_OBJECT_BUT_RECEIVED_P, T___MOD__, self);
             PythonContext context = PythonContext.get(inliningTarget);
             PythonLanguage language = context.getLanguage(inliningTarget);
             Object state = IndirectCallContext.enter(frame, language, context, indirectCallData);
             try {
-                return fromJavaStringNode.execute(new StringFormatProcessor(context, getTupleItemNode, selfStr, inliningTarget).format(assertNoJavaString(right)), TS_ENCODING);
+                return fromJavaStringNode.execute(new StringFormatProcessor(context, selfStr, inliningTarget).format(assertNoJavaString(right)), TS_ENCODING);
             } finally {
                 IndirectCallContext.exit(frame, language, context, state);
             }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/lib/PyTupleSizeNode.java

@@ -67,6 +67,10 @@
 @GenerateInline
 @GenerateCached(false)
 public abstract class PyTupleSizeNode extends PNodeWithContext {
+    public static int executeUncached(Object tuple) {
+        return PyTupleSizeNodeGen.getUncached().execute(null, tuple);
+    }
+
     public abstract int execute(Node inliningTarget, Object tuple);
 
     @Specialization

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

@@ -61,7 +61,6 @@
 import com.oracle.graal.python.builtins.objects.ints.PInt;
 import com.oracle.graal.python.builtins.objects.str.PString;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
-import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.lib.PyMappingCheckNode;
 import com.oracle.graal.python.lib.PyObjectAsciiNode;
 import com.oracle.graal.python.nodes.ErrorMessages;
@@ -78,8 +77,8 @@ public class BytesFormatProcessor extends FormatProcessor<byte[]> {
     private final byte[] formatBytes;
     private final int bytesLength;
 
-    public BytesFormatProcessor(Python3Core core, TupleBuiltins.GetItemNode getTupleItemNode, byte[] formatBytes, int bytesLength, Node raisingNode) {
-        super(core, getTupleItemNode, new BytesFormattingBuffer(), raisingNode);
+    public BytesFormatProcessor(Python3Core core, byte[] formatBytes, int bytesLength, Node raisingNode) {
+        super(core, new BytesFormattingBuffer(), raisingNode);
         this.formatBytes = formatBytes;
         this.bytesLength = bytesLength;
     }

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

@@ -20,13 +20,13 @@
 import com.oracle.graal.python.builtins.PythonBuiltinClassType;
 import com.oracle.graal.python.builtins.objects.function.PKeyword;
 import com.oracle.graal.python.builtins.objects.ints.PInt;
-import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.lib.PyFloatAsDoubleNode;
 import com.oracle.graal.python.lib.PyNumberCheckNode;
 import com.oracle.graal.python.lib.PyNumberIndexNode;
 import com.oracle.graal.python.lib.PyNumberLongNode;
 import com.oracle.graal.python.lib.PyObjectGetItem;
-import com.oracle.graal.python.lib.PyObjectSizeNode;
+import com.oracle.graal.python.lib.PyTupleGetItem;
+import com.oracle.graal.python.lib.PyTupleSizeNode;
 import com.oracle.graal.python.nodes.ErrorMessages;
 import com.oracle.graal.python.nodes.PGuards;
 import com.oracle.graal.python.nodes.PRaiseNode;
@@ -58,17 +58,15 @@ abstract class FormatProcessor<T> {
     /** see {@link #getArg()} for the meaning of this value. */
     private int argIndex = -1;
     private Object args;
-    private final TupleBuiltins.GetItemNode getTupleItemNode;
 
     protected int index;
     protected final Python3Core core;
     protected final Node raisingNode;
     protected final FormattingBuffer buffer;
 
-    public FormatProcessor(Python3Core core, TupleBuiltins.GetItemNode getTupleItemNode, FormattingBuffer buffer, Node raisingNode) {
+    public FormatProcessor(Python3Core core, FormattingBuffer buffer, Node raisingNode) {
         this.core = core;
         this.raisingNode = raisingNode;
-        this.getTupleItemNode = getTupleItemNode;
         this.buffer = buffer;
         index = 0;
     }
@@ -101,10 +99,6 @@ static Object call(Object callable, Object... args) {
         return CallNode.executeUncached(callable, args, PKeyword.EMPTY_KEYWORDS);
     }
 
-    Object getItem(Object arg, Object arg2) {
-        return PyObjectGetItem.executeUncached(arg, arg2);
-    }
-
     Object getArg() {
         Object ret = null;
         switch (argIndex) {
@@ -121,7 +115,7 @@ Object getArg() {
                 // directly, so the only error can be IndexError, which we ignore and transform into
                 // the TypeError below.
                 try {
-                    ret = getTupleItemNode.execute(null, args, argIndex++);
+                    ret = PyTupleGetItem.executeUncached(args, argIndex++);
                 } catch (PException e) {
                     // fall through
                 }
@@ -174,7 +168,7 @@ private static boolean useIndexMagicMethod(char specType) {
         return specType == 'x' || specType == 'X' || specType == 'o' || specType == 'c';
     }
 
-    protected final Object asNumber(Object arg, char specType) {
+    protected static Object asNumber(Object arg, char specType) {
         if (arg instanceof Integer || arg instanceof Long || arg instanceof PInt) {
             // arg is already acceptable
             return arg;
@@ -328,7 +322,7 @@ private T formatImpl(Object args1) {
                 Object tmp = parseMappingKey(keyStart, index - 1);
                 // Look it up using this extent as the (right type of) key. The caller must have
                 // pushed the frame.
-                this.args = getItem(mapping, tmp);
+                this.args = PyObjectGetItem.executeUncached(mapping, tmp);
             } else {
                 // Not a mapping key: next clause will re-read c.
                 push();
@@ -489,7 +483,7 @@ private T formatImpl(Object args1) {
          * of range; if a special value, it would be wrong if it were -1, indicating a single item
          * that has not yet been used.
          */
-        if (argIndex == -1 || (argIndex >= 0 && PyObjectSizeNode.executeUncached(args1) >= argIndex + 1)) {
+        if (argIndex == -1 || (argIndex >= 0 && PyTupleSizeNode.executeUncached(args1) >= argIndex + 1)) {
             throw PRaiseNode.raiseStatic(raisingNode, TypeError, ErrorMessages.NOT_ALL_ARGS_CONVERTED_DURING_FORMATTING, getFormatType());
         }
 

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

@@ -15,7 +15,6 @@
 import com.oracle.graal.python.builtins.Python3Core;
 import com.oracle.graal.python.builtins.objects.str.PString;
 import com.oracle.graal.python.builtins.objects.tuple.PTuple;
-import com.oracle.graal.python.builtins.objects.tuple.TupleBuiltins;
 import com.oracle.graal.python.lib.PyMappingCheckNode;
 import com.oracle.graal.python.lib.PyObjectAsciiNode;
 import com.oracle.graal.python.lib.PyObjectReprAsTruffleStringNode;
@@ -29,8 +28,8 @@
 public final class StringFormatProcessor extends FormatProcessor<String> {
     private final String formatText;
 
-    public StringFormatProcessor(Python3Core core, TupleBuiltins.GetItemNode getTupleItemNode, String format, Node raisingNode) {
-        super(core, getTupleItemNode, new FormattingBuffer.StringFormattingBuffer(format.length() + 100), raisingNode);
+    public StringFormatProcessor(Python3Core core, String format, Node raisingNode) {
+        super(core, new FormattingBuffer.StringFormattingBuffer(format.length() + 100), raisingNode);
         index = 0;
         this.formatText = format;
     }