Use qualified module name from import statement during importing (#1079)

* Use qualified module name from import statement during importing

* Add tests from gh936

Author: BCSharp

Src/IronPython/Runtime/Importer.cs

@@ -86,10 +86,10 @@ public static object ImportFrom(CodeContext/*!*/ context, object from, string na
 
                 if (scope.__dict__._storage.TryGetPath(out object path)) {
                     if (path is PythonList listPath) {
-                        return ImportNestedModule(context, scope, new[] { name }, 0, listPath);
+                        return ImportNestedModule(context, scope, new ArraySegment<string>(new[] { name }), listPath, scope.GetName());
                     }
                     if (path is string stringPath) {
-                        return ImportNestedModule(context, scope, new[] { name }, 0, PythonList.FromArrayNoCopy(stringPath));
+                        return ImportNestedModule(context, scope, new ArraySegment<string>(new[] { name }), PythonList.FromArrayNoCopy(stringPath), scope.GetName());
                     }
                 }
             } else if (from is PythonType pt) {
@@ -112,25 +112,26 @@ public static object ImportFrom(CodeContext/*!*/ context, object from, string na
             throw PythonOps.ImportError("Cannot import name {0}", name);
         }
 
-        private static object ImportModuleFrom(CodeContext/*!*/ context, object from, string[] parts, int current) {
+        private static object ImportModuleFrom(CodeContext/*!*/ context, object from, ArraySegment<string> parts, object root) {
             if (from is PythonModule scope) {
                 if (scope.__dict__._storage.TryGetPath(out object path) || DynamicHelpers.GetPythonType(scope).TryGetMember(context, scope, "__path__", out path)) {
                     if (path is PythonList listPath) {
-                        return ImportNestedModule(context, scope, parts, current, listPath);
+                        return ImportNestedModule(context, scope, parts, listPath, (root as PythonModule)?.GetName());
                     }
                     if (path is string stringPath) {
-                        return ImportNestedModule(context, scope, parts, current, PythonList.FromArrayNoCopy(stringPath));
+                        return ImportNestedModule(context, scope, parts, PythonList.FromArrayNoCopy(stringPath), (root as PythonModule)?.GetName());
                     }
                 }
             }
 
+            string name = parts.Array[parts.Offset + parts.Count - 1];
             if (from is NamespaceTracker ns) {
-                if (ns.TryGetValue(parts[current], out object val)) {
+                if (ns.TryGetValue(name, out object val)) {
                     return MemberTrackerToPython(context, val);
                 }
             }
 
-            throw PythonOps.ImportError("No module named {0}", parts[current]);
+            throw PythonOps.ImportError("No module named {0}", name);
         }
 
         /// <summary>
@@ -262,7 +263,7 @@ public static object ImportModule(CodeContext/*!*/ context, object globals, stri
                     }
                 } else if (i != 0) {
                     // child module isn't loaded yet, import it.
-                    next = ImportModuleFrom(context, next, parts, i);
+                    next = ImportModuleFrom(context, next, new ArraySegment<string>(parts, 1, i), newmod);
                 } else {
                     // top-level module doesn't exist in sys.modules, probably
                     // came from some weird meta path hook.
@@ -603,17 +604,21 @@ private static bool TryGetNestedModule(CodeContext/*!*/ context, PythonModule/*!
         }
 
         private static object ImportNestedModule(CodeContext/*!*/ context, PythonModule/*!*/ module,
-            string[] parts, int current, PythonList/*!*/ path) {
+            ArraySegment<string> parts, PythonList/*!*/ path, string scopeModuleName) {
+            Debug.Assert(parts.Array is not null);
+            Debug.Assert(parts.Count > 0);
+
             object ret;
-            string name = parts[current];
-            string fullName = CreateFullName(module.GetName() as string, name);
+            int current = parts.Offset + parts.Count - 1;
+            string name = parts.Array[current];
+            string fullName = CreateFullName(scopeModuleName, parts);
 
             if (TryGetExistingOrMetaPathModule(context, fullName, path, out ret)) {
                 module.__dict__[name] = ret;
                 return ret;
             }
 
-            if (TryGetNestedModule(context, module, parts, current, out ret)) {
+            if (TryGetNestedModule(context, module, parts.Array, current, out ret)) {
                 return ret;
             }
 
@@ -762,11 +767,11 @@ private static bool IsReflected(object module) {
                 || module is BuiltinFunction;
         }
 
-        private static string CreateFullName(string/*!*/ baseName, string name) {
+        private static string CreateFullName(string/*!*/ baseName, ArraySegment<string> parts) {
             if (baseName == null || baseName.Length == 0 || baseName == "__main__") {
-                return name;
+                return string.Join(".", parts);
             }
-            return baseName + "." + name;
+            return baseName + "." + string.Join(".", parts);
         }
 
         #endregion

Tests/import_extant/_vendor/__init__.py

@@ -0,0 +1 @@
+Infinity = None

Tests/import_extant/_vendor/packaging/__init__.py

@@ -0,0 +1 @@
+from ._structures import Infinity

Tests/import_extant/_vendor/packaging/_structures.py

@@ -0,0 +1,72 @@
+import sys
+
+class VendorImporter:
+    """
+    A PEP 302 meta path importer for finding optionally-vendored
+    or otherwise naturally-installed packages from root_name.
+    """
+
+    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
+        self.root_name = root_name
+        self.vendored_names = set(vendored_names)
+        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')
+
+    @property
+    def search_path(self):
+        """
+        Search first the vendor package then as a natural package.
+        """
+        yield self.vendor_pkg + '.'
+        yield ''
+
+    def find_module(self, fullname, path=None):
+        """
+        Return self when fullname starts with root_name and the
+        target module is one vendored through this importer.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        if root:
+            return
+        if not any(map(target.startswith, self.vendored_names)):
+            return
+        return self
+
+    def load_module(self, fullname):
+        """
+        Iterate over the search path to locate and load fullname.
+        """
+        root, base, target = fullname.partition(self.root_name + '.')
+        for prefix in self.search_path:
+            try:
+                extant = prefix + target
+                __import__(extant)
+                mod = sys.modules[extant]
+                sys.modules[fullname] = mod
+                # mysterious hack:
+                # Remove the reference to the extant package/module
+                # on later Python versions to cause relative imports
+                # in the vendor package to resolve the same modules
+                # as those going through this importer.
+                if sys.version_info > (3, 3):
+                    del sys.modules[extant]
+                return mod
+            except ImportError:
+                pass
+        else:
+            raise ImportError(
+                "The '{target}' package is required; "
+                "normally this is bundled with this package so if you get "
+                "this warning, consult the packager of your "
+                "distribution.".format(**locals())
+            )
+
+    def install(self):
+        """
+        Install this importer into sys.meta_path if not already present.
+        """
+        if self not in sys.meta_path:
+            sys.meta_path.append(self)
+
+
+names = 'packaging',
+VendorImporter(__name__, names).install()

Tests/import_extant/_vendor/packaging/version.py

@@ -0,0 +1,45 @@
+# Licensed to the .NET Foundation under one or more agreements.
+# The .NET Foundation licenses this file to you under the Apache 2.0 License.
+# See the LICENSE file in the project root for more information.
+
+import os
+import sys
+import unittest
+
+from iptest import IronPythonTestCase, run_test
+
+
+class ImportExtant(IronPythonTestCase):
+    def test_gh936(self):
+        # https://github.com/IronLanguages/ironpython3/issues/936
+
+        extra_import_path = os.path.join(self.test_dir, "import_extant") 
+        sys.path.insert(0, extra_import_path)
+        try:
+            m = __import__('extern.packaging.version')
+            self.assertEqual(m.__name__, "extern")
+            self.assertEqual(m.__package__, "extern")
+            self.assertTrue(hasattr(m, "VendorImporter"))
+            self.assertTrue(hasattr(m, "packaging"))
+
+            self.assertEqual(m.packaging.__name__, "_vendor.packaging")
+            self.assertEqual(m.packaging.__package__, "_vendor.packaging")
+
+            self.assertEqual(m.packaging.version.__name__, "extern.packaging.version")
+            self.assertEqual(m.packaging.version.__package__, "extern.packaging")
+
+            self.assertIn("extern", sys.modules.keys())
+            self.assertIs(m, sys.modules["extern"])
+
+            self.assertIn("extern.packaging", sys.modules.keys())
+            self.assertIs(m.packaging, sys.modules["extern.packaging"])
+
+            self.assertIn("extern.packaging.version", sys.modules.keys())
+            self.assertIs(m.packaging.version, sys.modules["extern.packaging.version"])
+
+            self.assertIsNone(m.packaging.version.Infinity)
+        finally:
+            sys.path.remove(extra_import_path)
+
+run_test(__name__)
+