Fix truffle warnings

Author: otethal

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/Python3Core.java

@@ -909,9 +909,8 @@ private void initializeImportlib() {
                     if (zipimporter == PNone.NO_VALUE) {
                         LOGGER.log(Level.FINE, () -> "# can't import zipimport.zipimporter");
                     } else {
-                        SequenceStorageNodes.InsertItemNode insertItem = SequenceStorageNodes.InsertItemNode.getUncached();
                         SequenceStorage store = pathHooksList.getSequenceStorage();
-                        pathHooksList.setSequenceStorage(insertItem.execute(store, 0, zipimporter));
+                        pathHooksList.setSequenceStorage(SequenceStorageNodes.InsertItemNode.executeUncached(store, 0, zipimporter));
                         LOGGER.log(Level.FINE, () -> "# installed zipimport hook");
                     }
                 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ArrayModuleBuiltins.java

@@ -183,6 +183,7 @@ PArray array(Object cls, TruffleString typeCode, @SuppressWarnings("unused") PNo
 
             @Specialization
             PArray arrayWithRangeInitializer(Object cls, TruffleString typeCode, PIntRange range,
+                            @Bind("this") Node inliningTarget,
                             @Shared @Cached ArrayNodes.PutValueNode putValueNode,
                             @Shared @Cached TruffleString.CodePointLengthNode lengthNode,
                             @Shared @Cached TruffleString.CodePointAtIndexNode atIndexNode) {
@@ -200,7 +201,7 @@ PArray arrayWithRangeInitializer(Object cls, TruffleString typeCode, PIntRange r
                 int len = range.getIntLength();
 
                 for (int index = 0, value = start; index < len; index++, value += step) {
-                    putValueNode.execute(null, array, index, value);
+                    putValueNode.execute(null, inliningTarget, array, index, value);
                 }
 
                 return array;
@@ -231,7 +232,9 @@ PArray arrayWithStringInitializer(VirtualFrame frame, Object cls, TruffleString
             }
 
             @Specialization
+            @SuppressWarnings("truffle-static-method")
             PArray arrayArrayInitializer(VirtualFrame frame, Object cls, TruffleString typeCode, PArray initializer,
+                            @Bind("this") Node inliningTarget,
                             @Shared @Cached ArrayNodes.PutValueNode putValueNode,
                             @Cached ArrayNodes.GetValueNode getValueNode,
                             @Shared @Cached TruffleString.CodePointLengthNode lengthNode,
@@ -240,7 +243,7 @@ PArray arrayArrayInitializer(VirtualFrame frame, Object cls, TruffleString typeC
                 try {
                     PArray array = getFactory().createArray(cls, typeCode, format, initializer.getLength());
                     for (int i = 0; i < initializer.getLength(); i++) {
-                        putValueNode.execute(frame, array, i, getValueNode.execute(initializer, i));
+                        putValueNode.execute(frame, inliningTarget, array, i, getValueNode.execute(inliningTarget, initializer, i));
                     }
                     return array;
                 } catch (OverflowException e) {
@@ -250,7 +253,9 @@ PArray arrayArrayInitializer(VirtualFrame frame, Object cls, TruffleString typeC
             }
 
             @Specialization(guards = "!isBytes(initializer)")
+            @SuppressWarnings("truffle-static-method")
             PArray arraySequenceInitializer(VirtualFrame frame, Object cls, TruffleString typeCode, PSequence initializer,
+                            @Bind("this") Node inliningTarget,
                             @Shared @Cached ArrayNodes.PutValueNode putValueNode,
                             @Cached SequenceNodes.GetSequenceStorageNode getSequenceStorageNode,
                             @Cached SequenceStorageNodes.GetItemScalarNode getItemNode,
@@ -262,7 +267,7 @@ PArray arraySequenceInitializer(VirtualFrame frame, Object cls, TruffleString ty
                 try {
                     PArray array = getFactory().createArray(cls, typeCode, format, length);
                     for (int i = 0; i < length; i++) {
-                        putValueNode.execute(frame, array, i, getItemNode.execute(storage, i));
+                        putValueNode.execute(frame, inliningTarget, array, i, getItemNode.execute(storage, i));
                     }
                     return array;
                 } catch (OverflowException e) {
@@ -302,7 +307,7 @@ PArray arrayIteratorInitializer(VirtualFrame frame, Object cls, TruffleString ty
                         CompilerDirectives.transferToInterpreterAndInvalidate();
                         throw raise(MemoryError);
                     }
-                    putValueNode.execute(frame, array, length - 1, nextValue);
+                    putValueNode.execute(frame, inliningTarget, array, length - 1, nextValue);
                 }
 
                 array.setLength(length);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/BuiltinConstructors.java

@@ -131,7 +131,6 @@
 import com.oracle.graal.python.builtins.objects.common.HashingCollectionNodes;
 import com.oracle.graal.python.builtins.objects.common.HashingStorage;
 import com.oracle.graal.python.builtins.objects.common.SequenceNodes.GetObjectArrayNode;
-import com.oracle.graal.python.builtins.objects.common.SequenceNodesFactory.GetObjectArrayNodeGen;
 import com.oracle.graal.python.builtins.objects.complex.PComplex;
 import com.oracle.graal.python.builtins.objects.dict.PDict;
 import com.oracle.graal.python.builtins.objects.ellipsis.PEllipsis;
@@ -318,13 +317,14 @@ PBytes doCallBytes(VirtualFrame frame, Object cls, Object source, PNone encoding
                     throw raise(TypeError, ErrorMessages.RETURNED_NONBYTES, T___BYTES__, bytes);
                 }
             }
-            return factory().createBytes(cls, bytesInitNode.execute(frame, source, encoding, errors));
+            return factory().createBytes(cls, bytesInitNode.execute(frame, inliningTarget, source, encoding, errors));
         }
 
         @Specialization(guards = {"isNoValue(source) || (!isNoValue(encoding) || !isNoValue(errors))"})
         PBytes dontCallBytes(VirtualFrame frame, Object cls, Object source, Object encoding, Object errors,
+                        @Bind("this") Node inliningTarget,
                         @Shared @Cached BytesNodes.BytesInitNode bytesInitNode) {
-            return factory().createBytes(cls, bytesInitNode.execute(frame, source, encoding, errors));
+            return factory().createBytes(cls, bytesInitNode.execute(frame, inliningTarget, source, encoding, errors));
         }
     }
 
@@ -1056,8 +1056,9 @@ public PFrozenSet subFrozensetIdentity(Object cls, PFrozenSet arg,
 
         @Specialization(guards = {"!isNoValue(iterable)", "!isPFrozenSet(iterable)"})
         public PFrozenSet frozensetIterable(VirtualFrame frame, Object cls, Object iterable,
+                        @Bind("this") Node inliningTarget,
                         @Cached HashingCollectionNodes.GetClonedHashingStorageNode getHashingStorageNode) {
-            HashingStorage storage = getHashingStorageNode.doNoValue(frame, iterable);
+            HashingStorage storage = getHashingStorageNode.doNoValue(frame, inliningTarget, iterable);
             return factory().createFrozenSet(cls, storage);
         }
     }
@@ -2313,8 +2314,9 @@ public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PD
         @Specialization
         public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PDict globals, @SuppressWarnings("unused") PNone name, @SuppressWarnings("unused") PNone defaultArgs,
                         PTuple closure,
+                        @Bind("this") Node inliningTarget,
                         @Shared("getObjectArrayNode") @Cached GetObjectArrayNode getObjectArrayNode) {
-            return factory().createFunction(T_LAMBDA_NAME, code, globals, PCell.toCellArray(getObjectArrayNode.execute(closure)));
+            return factory().createFunction(T_LAMBDA_NAME, code, globals, PCell.toCellArray(getObjectArrayNode.execute(inliningTarget, closure)));
         }
 
         @Specialization
@@ -2326,30 +2328,34 @@ public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PD
 
         @Specialization
         public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PDict globals, TruffleString name, @SuppressWarnings("unused") PNone defaultArgs, PTuple closure,
+                        @Bind("this") Node inliningTarget,
                         @Shared("getObjectArrayNode") @Cached GetObjectArrayNode getObjectArrayNode) {
-            return factory().createFunction(name, code, globals, PCell.toCellArray(getObjectArrayNode.execute(closure)));
+            return factory().createFunction(name, code, globals, PCell.toCellArray(getObjectArrayNode.execute(inliningTarget, closure)));
         }
 
         @Specialization
         public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PDict globals, @SuppressWarnings("unused") PNone name, PTuple defaultArgs,
                         @SuppressWarnings("unused") PNone closure,
+                        @Bind("this") Node inliningTarget,
                         @Shared("getObjectArrayNode") @Cached GetObjectArrayNode getObjectArrayNode) {
             // TODO split defaults of positional args from kwDefaults
-            return factory().createFunction(code.getName(), code, globals, getObjectArrayNode.execute(defaultArgs), null, null);
+            return factory().createFunction(code.getName(), code, globals, getObjectArrayNode.execute(inliningTarget, defaultArgs), null, null);
         }
 
         @Specialization
         public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PDict globals, TruffleString name, PTuple defaultArgs, @SuppressWarnings("unused") PNone closure,
+                        @Bind("this") Node inliningTarget,
                         @Shared("getObjectArrayNode") @Cached GetObjectArrayNode getObjectArrayNode) {
             // TODO split defaults of positional args from kwDefaults
-            return factory().createFunction(name, code, globals, getObjectArrayNode.execute(defaultArgs), null, null);
+            return factory().createFunction(name, code, globals, getObjectArrayNode.execute(inliningTarget, defaultArgs), null, null);
         }
 
         @Specialization
         public PFunction function(@SuppressWarnings("unused") Object cls, PCode code, PDict globals, TruffleString name, PTuple defaultArgs, PTuple closure,
+                        @Bind("this") Node inliningTarget,
                         @Shared("getObjectArrayNode") @Cached GetObjectArrayNode getObjectArrayNode) {
             // TODO split defaults of positional args from kwDefaults
-            return factory().createFunction(name, code, globals, getObjectArrayNode.execute(defaultArgs), null, PCell.toCellArray(getObjectArrayNode.execute(closure)));
+            return factory().createFunction(name, code, globals, getObjectArrayNode.execute(inliningTarget, defaultArgs), null, PCell.toCellArray(getObjectArrayNode.execute(inliningTarget, closure)));
         }
 
         @Fallback
@@ -2375,7 +2381,6 @@ public PFunction function(Object cls, Object method_def, Object def, Object name
     @GenerateNodeFactory
     public abstract static class TypeNode extends PythonVarargsBuiltinNode {
         @Child private IsSubtypeNode isSubtypeNode;
-        @Child private GetObjectArrayNode getObjectArrayNode;
         @Child private IsAcceptableBaseNode isAcceptableBaseNode;
 
         public abstract Object execute(VirtualFrame frame, Object cls, Object name, Object bases, Object dict, PKeyword[] kwds);
@@ -2411,11 +2416,12 @@ Object typeNew(VirtualFrame frame, Object cls, Object wName, PTuple bases, PDict
                         @Cached PyObjectLookupAttr lookupMroEntriesNode,
                         @Cached CastToTruffleStringNode castStr,
                         @Cached CallNode callNewFuncNode,
-                        @Cached CreateTypeNode createType) {
+                        @Cached CreateTypeNode createType,
+                        @Cached GetObjectArrayNode getObjectArrayNode) {
             // Determine the proper metatype to deal with this
             TruffleString name = castStr.execute(wName);
             Object metaclass = cls;
-            Object winner = calculateMetaclass(frame, inliningTarget, metaclass, bases, getClassNode, isTypeNode, lookupMroEntriesNode);
+            Object winner = calculateMetaclass(frame, inliningTarget, metaclass, bases, getClassNode, isTypeNode, lookupMroEntriesNode, getObjectArrayNode);
             if (winner != metaclass) {
                 Object newFunc = getNewFuncNode.execute(winner);
                 if (newFunc instanceof PBuiltinMethod && (((PBuiltinMethod) newFunc).getFunction().getFunctionRootNode().getCallTarget() == getRootNode().getCallTarget())) {
@@ -2442,9 +2448,9 @@ Object generic(@SuppressWarnings("unused") Object cls, @SuppressWarnings("unused
         }
 
         private Object calculateMetaclass(VirtualFrame frame, Node inliningTarget, Object cls, PTuple bases, InlinedGetClassNode getClassNode, IsTypeNode isTypeNode,
-                        PyObjectLookupAttr lookupMroEntries) {
+                        PyObjectLookupAttr lookupMroEntries, GetObjectArrayNode getObjectArrayNode) {
             Object winner = cls;
-            for (Object base : ensureGetObjectArrayNode().execute(bases)) {
+            for (Object base : getObjectArrayNode.execute(inliningTarget, bases)) {
                 if (!isTypeNode.execute(base) && lookupMroEntries.execute(frame, base, T___MRO_ENTRIES__) != PNone.NO_VALUE) {
                     throw raise(TypeError, ErrorMessages.TYPE_DOESNT_SUPPORT_MRO_ENTRY_RESOLUTION);
                 }
@@ -2493,14 +2499,6 @@ Object typeGeneric(VirtualFrame frame, Object cls, Object name, Object bases, Ob
             return nextTypeNode.execute(frame, cls, name, bases, dict, kwds);
         }
 
-        private GetObjectArrayNode ensureGetObjectArrayNode() {
-            if (getObjectArrayNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                getObjectArrayNode = insert(GetObjectArrayNodeGen.create());
-            }
-            return getObjectArrayNode;
-        }
-
         private IsAcceptableBaseNode ensureIsAcceptableBaseNode() {
             if (isAcceptableBaseNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
@@ -2792,18 +2790,19 @@ PCode call(VirtualFrame frame, @SuppressWarnings("unused") Object cls, int argco
                         PTuple varnames, TruffleString filename, TruffleString name,
                         int firstlineno, PBytes linetable,
                         PTuple freevars, PTuple cellvars,
+                        @Bind("this") Node inliningTarget,
                         @CachedLibrary(limit = "1") PythonBufferAccessLibrary bufferLib,
                         @Cached CodeNodes.CreateCodeNode createCodeNode,
                         @Cached GetObjectArrayNode getObjectArrayNode,
                         @Cached CastToTruffleStringNode castToTruffleStringNode) {
             byte[] codeBytes = bufferLib.getCopiedByteArray(codestring);
             byte[] linetableBytes = bufferLib.getCopiedByteArray(linetable);
 
-            Object[] constantsArr = getObjectArrayNode.execute(constants);
-            TruffleString[] namesArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(names), castToTruffleStringNode);
-            TruffleString[] varnamesArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(varnames), castToTruffleStringNode);
-            TruffleString[] freevarsArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(freevars), castToTruffleStringNode);
-            TruffleString[] cellcarsArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(cellvars), castToTruffleStringNode);
+            Object[] constantsArr = getObjectArrayNode.execute(inliningTarget, constants);
+            TruffleString[] namesArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(inliningTarget, names), castToTruffleStringNode);
+            TruffleString[] varnamesArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(inliningTarget, varnames), castToTruffleStringNode);
+            TruffleString[] freevarsArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(inliningTarget, freevars), castToTruffleStringNode);
+            TruffleString[] cellcarsArr = objectArrayToTruffleStringArray(getObjectArrayNode.execute(inliningTarget, cellvars), castToTruffleStringNode);
 
             return createCodeNode.execute(frame, argcount, posonlyargcount, kwonlyargcount,
                             nlocals, stacksize, flags,