Disallow compilation during module import

During the compilation of one Entrypointed function it's possible to import a module which
calls a second Entrypointed function. This breaks our model of the
compilation process and could cause deadlocks, so instead throw an
ImportError.

Author: William Grant

typed_python/compiler/compiler_cache_test.py

@@ -654,3 +654,38 @@ def g(x):
         # run twice to check cached code can be retrieved
         assert evaluateExprInFreshProcess(MODULE, 'x.getX()', compilerCacheDir) == 1
         assert evaluateExprInFreshProcess(MODULE, 'x.getX()', compilerCacheDir) == 1
+
+
+@pytest.mark.skipif('sys.platform=="darwin"')
+def test_compiler_cache_throws_on_import_loop():
+    """It is possible, when compiling a module, to attempt to deserialise
+    a callTarget containing a module import which runs an Entrypointed function.
+    This results in a 'compilation loop' where one iteration of the conversion
+    is waiting on another, which currently breaks our model of the compilation
+    process.
+    """
+    module1 = """
+    @Entrypoint
+    def f(x):
+        return x+1
+    f(1)
+    """.replace('\n    ', '\n')
+    module2 = """
+    @Entrypoint
+    def g():
+        import x
+    """.replace('\n    ', '\n')
+    module3 = """
+    import y
+    def rung():
+        try:
+            y.g()
+        except ImportError as e:
+            return 'ImportError caught'
+    rung()
+    """.replace('\n    ', '\n')
+    with tempfile.TemporaryDirectory() as compilerCacheDir:
+
+        evaluateExprInFreshProcess({'x.py': module1}, 'x.f(1)', compilerCacheDir)
+        exception_string = evaluateExprInFreshProcess({'z.py': module3, 'y.py': module2, 'x.py': module1, }, 'z.rung()', compilerCacheDir)
+        assert exception_string == 'ImportError caught'

typed_python/compiler/runtime.py

@@ -12,6 +12,7 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 
+import inspect
 import threading
 import os
 import time
@@ -501,6 +502,14 @@ def Entrypoint(pyFunc):
 
         if not callable(typedFunc):
             raise Exception(f"Can only compile functions, not {typedFunc}")
+        # check if we are already in the middle of the compilation process, due to the Entrypointed
+        # code being called through a module import, and throw an error if so.
+        if is_importing():
+            compiling_func = Runtime.singleton().converter._currentlyConverting
+            compiling_func_link_name = Runtime.singleton().converter._link_name_for_identity[compiling_func]
+            error_message = f"Can't import Entrypointed code {pyFunc.__module__}.{pyFunc.__qualname__} \
+                while {compiling_func_link_name} is being compiled."
+            raise ImportError(error_message)
 
         typedFunc = Function(typedFunc)
 
@@ -534,3 +543,20 @@ def Compiled(pyFunc):
     f.resultTypeFor(*types)
 
     return f
+
+
+def is_importing():
+    """Walk the stack to check if we are currently importing a module.
+
+    In this case, we will have an 'importlib' between two 'typed_python.compiler.runtime' frames.
+    """
+    in_runtime = False
+    assert __name__ == 'typed_python.compiler.runtime', 'is_importing() should only be called from typed_python.compiler.runtime'
+    for frame, *_ in inspect.stack()[::-1]:
+        frame_name = frame.f_globals.get("__name__")
+        if frame_name == 'typed_python.compiler.runtime':
+            in_runtime = True
+        if in_runtime and frame_name == 'importlib':
+            return True
+
+    return False