go the route of a thread-local to make load the full path of a java import

Author: timfel

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

@@ -61,6 +61,7 @@
 import static com.oracle.graal.python.nodes.BuiltinNames.__BUILTIN__;
 import static com.oracle.graal.python.nodes.BuiltinNames.__DEBUG__;
 import static com.oracle.graal.python.nodes.BuiltinNames.__DUMP_TRUFFLE_AST__;
+import static com.oracle.graal.python.nodes.BuiltinNames.__JYTHON_CURRENT_IMPORT__;
 import static com.oracle.graal.python.nodes.HiddenAttributes.ID_KEY;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__NAME__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.__INSTANCECHECK__;
@@ -1881,6 +1882,15 @@ protected static boolean isFunction(Object callee) {
         }
     }
 
+    @Builtin(name = __JYTHON_CURRENT_IMPORT__, minNumOfPositionalArgs = 0)
+    @GenerateNodeFactory
+    public abstract static class CurrentImport extends PythonBuiltinNode {
+        @Specialization
+        String doIt() {
+            return getContext().getCurrentImport();
+        }
+    }
+
     @Builtin(name = "input", parameterNames = {"prompt"})
     @GenerateNodeFactory
     abstract static class InputNode extends PythonUnaryBuiltinNode {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/BuiltinNames.java

@@ -135,4 +135,5 @@ public abstract class BuiltinNames {
     // truffle specific builtins
     public static final String __BUILTIN__ = "__builtin__";
     public static final String __DUMP_TRUFFLE_AST__ = "__dump_truffle_ast__";
+    public static final String __JYTHON_CURRENT_IMPORT__ = "__jython_current_import__";
 }

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/statement/AbstractImportNode.java

@@ -58,22 +58,19 @@
 import com.oracle.graal.python.runtime.object.PythonObjectFactory;
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
-import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.TruffleLanguage.ContextReference;
-import com.oracle.truffle.api.TruffleLanguage.Env;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.instrumentation.StandardTags;
 import com.oracle.truffle.api.instrumentation.Tag;
-import com.oracle.truffle.api.profiles.BranchProfile;
 
 public abstract class AbstractImportNode extends StatementNode {
     @CompilationFinal private ContextReference<PythonContext> contextRef;
     @Child PythonObjectFactory objectFactory;
 
-    private final BranchProfile emulatesJython = BranchProfile.create();
     @Child private CallNode callNode;
     @Child private GetDictNode getDictNode;
     @Child private PassCaughtExceptionNode passExceptionNode;
+    @CompilationFinal private Boolean emulateJython;
 
     public AbstractImportNode() {
         super();
@@ -127,37 +124,19 @@ protected Object importModule(VirtualFrame frame, String name, Object globals, S
                 return builtinModule;
             }
         }
-        Env env = getContext().getEnv();
-        if (env.isHostLookupAllowed() && PythonOptions.getOption(env, PythonOptions.EmulateJython)) {
-            emulatesJython.enter();
-            forceClassloadingOnImport(name, fromList);
+        if (emulateJython()) {
+            if (fromList.length > 0) {
+                getContext().pushCurrentImport(name + "." + fromList[0]);
+            } else {
+                getContext().pushCurrentImport(name);
+            }
         }
-        return __import__(frame, name, globals, fromList, level);
-    }
-
-    /**
-     * Because of how Jython allows you to import classes that have not been
-     * loaded, yet, we need attempt to load types here, while we have the full
-     * string available. this will ensure that if there is such a Java class,
-     * its package will have been initialized and the importer code in java.py
-     * can find it.
-     */
-    @TruffleBoundary
-    private void forceClassloadingOnImport(String name, String[] fromList) {
-        Env env = getContext().getEnv();
         try {
-            env.lookupHostSymbol(name);
-        } catch (RuntimeException e) {
-            // ignore this, that's fine
-        }
-        for (String potentialClass : fromList) {
-            try {
-                env.lookupHostSymbol(name + "." + potentialClass);
-            } catch (RuntimeException e) {
-                continue;
+            return __import__(frame, name, globals, fromList, level);
+        } finally {
+            if (emulateJython()) {
+                getContext().popCurrentImport();
             }
-            // if we got here, we can stop. the package was loaded
-            break;
         }
     }
 
@@ -174,6 +153,14 @@ Object __import__(VirtualFrame frame, String name, Object globals, String[] from
         });
     }
 
+    private boolean emulateJython() {
+        if (emulateJython == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            emulateJython = PythonOptions.getFlag(getContext(), PythonOptions.EmulateJython);
+        }
+        return emulateJython;
+    }
+
     @Override
     public boolean hasTag(Class<? extends Tag> tag) {
         return tag == StandardTags.CallTag.class || super.hasTag(tag);

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/PythonContext.java

@@ -39,6 +39,7 @@
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
+import java.util.Stack;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Supplier;
@@ -142,6 +143,9 @@ public final class PythonContext {
     private final PosixResources resources;
     private final AsyncHandler handler;
 
+    // A thread-local to store the full path to the currently active import statement, for Jython compat
+    private final ThreadLocal<Stack<String>> currentImport = ThreadLocal.withInitial(() -> new Stack<>());
+
     public PythonContext(PythonLanguage language, TruffleLanguage.Env env, PythonCore core) {
         this.language = language;
         this.core = core;
@@ -721,4 +725,24 @@ public boolean isPyFileInLanguageHome(TruffleFile path) {
         PythonLanguage.getLogger().log(Level.FINE, () -> "Cannot access file " + path + " because there is no language home.");
         return false;
     }
+
+    @TruffleBoundary
+    public String getCurrentImport() {
+        Stack<String> ci = currentImport.get();
+        if (ci.isEmpty()) {
+            return "";
+        } else {
+            return ci.peek();
+        }
+    }
+
+    @TruffleBoundary
+    public void pushCurrentImport(String object) {
+        currentImport.get().push(object);
+    }
+
+    @TruffleBoundary
+    public void popCurrentImport() {
+        currentImport.get().pop();
+    }
 }

graalpython/lib-graalpython/java.py

@@ -130,6 +130,16 @@ class JavaImportFinder:
     if sys.graal_python_jython_emulation_enabled:
         @staticmethod
         def find_spec(fullname, path, target=None):
+            # Because of how Jython allows you to import classes that have not
+            # been loaded, yet, we need attempt to load types with the full
+            # string. This will ensure that if there is such a Java class, its
+            # package will have been initialized and thus the is_java_package
+            # check below will work
+            try:
+                type(__jython_current_import__())
+            except KeyError:
+                pass
+            # continue normally with import
             if JavaPackageLoader.is_java_package(fullname):
                 return _frozen_importlib.ModuleSpec(fullname, JavaPackageLoader, is_package=True)
             else:
@@ -151,3 +161,8 @@ def find_spec(fullname, path, target=None):
 sys.meta_path.append(JavaImportFinder)
 if sys.graal_python_jython_emulation_enabled:
     __getattr__ = JavaPackageLoader._make_getattr("java")
+else:
+    # remove __jython_current_import__ function from builtins module
+    import builtins
+    del builtins.__jython_current_import__
+    del builtins