[GR-66558] Make eval/exec work on top-level in embedding

PullRequest: graalpython/3860

Author: msimacek

graalpython/com.oracle.graal.python.test.integration/src/com/oracle/graal/python/test/integration/builtin/BuiltinFunctionTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2023, Oracle and/or its affiliates.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates.
  * Copyright (c) 2013, Regents of the University of California
  *
  * All rights reserved.
@@ -28,6 +28,7 @@
 import static com.oracle.graal.python.test.integration.PythonTests.assertPrintContains;
 import static com.oracle.graal.python.test.integration.PythonTests.assertPrints;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
 import org.graalvm.polyglot.Context;
@@ -382,4 +383,81 @@ public void cellType() {
         }
     }
 
+    @Test
+    public void testExec() {
+        Context context = PythonTests.enterContext();
+        try {
+            Value mainModule = context.getBindings("python");
+            Value exec = context.eval("python", "exec");
+            Value dict = context.eval("python", "dict");
+            // Inherited globals and locals
+            exec.execute("foo = 1");
+            assertTrue(mainModule.hasMember("foo"));
+            // Explicit globals
+            Value globals = dict.newInstance();
+            exec.execute("a = 1", globals);
+            assertTrue(globals.hasHashEntry("a"));
+            assertFalse(mainModule.hasMember("a"));
+            // Explicit globals and locals
+            Value locals = dict.newInstance();
+            exec.execute("b = a", globals, locals);
+            assertTrue(locals.hasHashEntry("b"));
+            assertFalse(globals.hasHashEntry("b"));
+            assertFalse(mainModule.hasMember("b"));
+            // Inherited globals, explicit locals
+            exec.execute("c = foo", mainModule.getMember("None"), locals);
+            assertTrue(locals.hasHashEntry("c"));
+            assertFalse(mainModule.hasMember("c"));
+        } finally {
+            PythonTests.closeContext();
+        }
+    }
+
+    @Test
+    public void testEval() {
+        Context context = PythonTests.enterContext();
+        try {
+            Value mainModule = context.getBindings("python");
+            Value eval = context.eval("python", "eval");
+            Value dict = context.eval("python", "dict");
+            mainModule.putMember("foo", 1);
+            // Inherited globals and locals
+            Value result = eval.execute("foo");
+            assertEquals(1, result.asInt());
+            // Explicit globals
+            Value globals = dict.newInstance();
+            globals.putHashEntry("a", 2);
+            result = eval.execute("a", globals);
+            assertEquals(2, result.asInt());
+            // Explicit globals and locals
+            Value locals = dict.newInstance();
+            locals.putHashEntry("b", 3);
+            result = eval.execute("b", globals, locals);
+            assertEquals(3, result.asInt());
+            result = eval.execute("a", globals, locals);
+            assertEquals(2, result.asInt());
+            // Inherited globals, explicit locals
+            Value none = mainModule.getMember("None");
+            result = eval.execute("b", none, locals);
+            assertEquals(3, result.asInt());
+            result = eval.execute("foo", none, locals);
+            assertEquals(1, result.asInt());
+        } finally {
+            PythonTests.closeContext();
+        }
+    }
+
+    @Test
+    public void testCompile() {
+        Context context = PythonTests.enterContext();
+        try {
+            Value compile = context.eval("python", "compile");
+            Value eval = context.eval("python", "eval");
+            Value code = compile.execute("1", "<input>", "eval");
+            Value result = eval.execute(code);
+            assertEquals(1, result.asInt());
+        } finally {
+            PythonTests.closeContext();
+        }
+    }
 }

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

@@ -788,16 +788,27 @@ abstract static class CreateEvalExecArgumentsNode extends Node {
         @Specialization
         static Object[] inheritGlobals(VirtualFrame frame, Node inliningTarget, @SuppressWarnings("unused") PNone globals, Object locals, TruffleString mode,
                         @Exclusive @Cached ReadCallerFrameNode readCallerFrameNode,
+                        @Exclusive @Cached GetOrCreateDictNode getOrCreateDictNode,
+                        @Exclusive @Cached InlinedConditionProfile haveCallerFrameProfile,
                         @Exclusive @Cached InlinedConditionProfile haveLocals,
                         @Exclusive @Cached PyMappingCheckNode mappingCheckNode,
                         @Exclusive @Cached GetFrameLocalsNode getFrameLocalsNode,
                         @Exclusive @Cached PRaiseNode raiseNode) {
             PFrame callerFrame = readCallerFrameNode.executeWith(frame, 0);
             Object[] args = PArguments.create();
-            PArguments.setGlobals(args, callerFrame.getGlobals());
+            boolean haveCallerFrame = haveCallerFrameProfile.profile(inliningTarget, callerFrame != null);
+            if (haveCallerFrame) {
+                PArguments.setGlobals(args, callerFrame.getGlobals());
+            } else {
+                PArguments.setGlobals(args, getOrCreateDictNode.execute(inliningTarget, PythonContext.get(inliningTarget).getMainModule()));
+            }
             if (haveLocals.profile(inliningTarget, locals instanceof PNone)) {
-                Object callerLocals = getFrameLocalsNode.execute(inliningTarget, callerFrame);
-                setCustomLocals(args, callerLocals);
+                if (haveCallerFrame) {
+                    Object callerLocals = getFrameLocalsNode.execute(inliningTarget, callerFrame);
+                    setCustomLocals(args, callerLocals);
+                } else {
+                    setCustomLocals(args, PArguments.getGlobals(args));
+                }
             } else {
                 if (!mappingCheckNode.execute(inliningTarget, locals)) {
                     throw raiseNode.raise(inliningTarget, TypeError, ErrorMessages.LOCALS_MUST_BE_MAPPING, mode, locals);
@@ -951,15 +962,21 @@ public final PCode compile(VirtualFrame frame, Object source, TruffleString file
         protected abstract Object executeInternal(VirtualFrame frame, Object source, TruffleString filename, TruffleString mode, int flags, boolean dontInherit, int optimize,
                         int featureVersion);
 
+        private int inheritFlags(VirtualFrame frame, int flags, ReadCallerFrameNode readCallerFrame) {
+            PFrame fr = readCallerFrame.executeWith(frame, 0);
+            if (fr != null) {
+                PCode code = PFactory.createCode(PythonLanguage.get(this), fr.getTarget());
+                flags |= code.getFlags() & PyCF_MASK;
+            }
+            return flags;
+        }
+
         @Specialization
         Object doCompile(VirtualFrame frame, TruffleString expression, TruffleString filename, TruffleString mode, int flags, boolean dontInherit, int optimize,
                         int featureVersion,
-                        @Shared @Cached ReadCallerFrameNode readCallerFrame,
-                        @Bind PythonLanguage language) {
+                        @Shared @Cached ReadCallerFrameNode readCallerFrame) {
             if (!dontInherit) {
-                PFrame fr = readCallerFrame.executeWith(frame, 0);
-                PCode code = PFactory.createCode(language, fr.getTarget());
-                flags |= code.getFlags() & PyCF_MASK;
+                flags = inheritFlags(frame, flags, readCallerFrame);
             }
             EncapsulatingNodeReference encapsulating = EncapsulatingNodeReference.getCurrent();
             Node encapsulatingNode = encapsulating.set(this);
@@ -1037,7 +1054,7 @@ Object compile(TruffleString expression, TruffleString filename, TruffleString m
 
         @Specialization(limit = "3")
         @SuppressWarnings("truffle-static-method")
-        Object generic(VirtualFrame frame, Object wSource, Object wFilename, TruffleString mode, int flags, @SuppressWarnings("unused") boolean dontInherit, int optimize, int featureVersion,
+        Object generic(VirtualFrame frame, Object wSource, Object wFilename, TruffleString mode, int flags, boolean dontInherit, int optimize, int featureVersion,
                         @CachedLibrary(limit = "3") PythonBufferAcquireLibrary acquireLib,
                         @CachedLibrary(limit = "3") PythonBufferAccessLibrary bufferLib,
                         @Bind PythonContext context,
@@ -1056,9 +1073,7 @@ Object generic(VirtualFrame frame, Object wSource, Object wFilename, TruffleStri
             TruffleString filename = asPath.execute(frame, wFilename);
 
             if (!dontInherit) {
-                PFrame fr = readCallerFrame.executeWith(frame, 0);
-                PCode code = PFactory.createCode(PythonLanguage.get(inliningTarget), fr.getTarget());
-                flags |= code.getFlags() & PyCF_MASK;
+                flags = inheritFlags(frame, flags, readCallerFrame);
             }
 
             EncapsulatingNodeReference encapsulating = EncapsulatingNodeReference.getCurrent();