Remove deprecated implicit assembly loading

lostmsu · lostmsu · commit 7ae19e2b9498 · 2020-11-11T11:32:39.000-08:00
Legacy behavior:
`import Company.Product.Namespace` would search for
`Company.Product.Namespace.dll` .NET assmebly, load it, and import the
namespace.

New behavior:
User must always explicitly add assembly reference using
`clr.AddReference` to `Company.Product.Namespace` prior to attempting
import
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -33,6 +33,10 @@ details about the cause of the failure
 -    Fixed a bug where indexers could not be used if they were inherited
 -    Made it possible to use `__len__` also on `ICollection<>` interface objects
 
+### Removed
+
+-   implicit assembly loading (you have to explicitly `clr.AddReference` before doing import)
+
 ## [2.5.0][] - 2020-06-14
 
 This version improves performance on benchmarks significantly compared to 2.3.
diff --git a/src/runtime/assemblymanager.cs b/src/runtime/assemblymanager.cs
@@ -252,75 +252,6 @@ public static Assembly FindLoadedAssembly(string name)
             return null;
         }
 
-        /// <summary>
-        /// Given a qualified name of the form A.B.C.D, attempt to load
-        /// an assembly named after each of A.B.C.D, A.B.C, A.B, A. This
-        /// will only actually probe for the assembly once for each unique
-        /// namespace. Returns true if any assemblies were loaded.
-        /// </summary>
-        /// <remarks>
-        /// TODO item 3 "* Deprecate implicit loading of assemblies":
-        /// Set the fromFile flag if the name of the loaded assembly matches
-        /// the fully qualified name that was requested if the framework
-        /// actually loads an assembly.
-        /// Call ONLY for namespaces that HAVE NOT been cached yet.
-        /// </remarks>
-        public static bool LoadImplicit(string name, Action<Exception> assemblyLoadErrorHandler, bool warn = true)
-        {
-            string[] names = name.Split('.');
-            var loaded = false;
-            var s = "";
-            Assembly lastAssembly = null;
-            HashSet<Assembly> assembliesSet = null;
-            for (var i = 0; i < names.Length; i++)
-            {
-                s = i == 0 ? names[0] : s + "." + names[i];
-                if (!probed.ContainsKey(s))
-                {
-                    if (assembliesSet == null)
-                    {
-                        assembliesSet = new HashSet<Assembly>(AppDomain.CurrentDomain.GetAssemblies());
-                    }
-                    Assembly a = FindLoadedAssembly(s);
-                    try
-                    {
-                        if (a == null)
-                        {
-                            a = LoadAssemblyPath(s);
-                        }
-
-                        if (a == null)
-                        {
-                            a = LoadAssembly(s);
-                        }
-                    }
-                    catch (FileLoadException e) { assemblyLoadErrorHandler(e); }
-                    catch (BadImageFormatException e) { assemblyLoadErrorHandler(e); }
-                    catch (System.Security.SecurityException e) { assemblyLoadErrorHandler(e); }
-                    catch (PathTooLongException e) { assemblyLoadErrorHandler(e); }
-
-                    if (a != null && !assembliesSet.Contains(a))
-                    {
-                        loaded = true;
-                        lastAssembly = a;
-                    }
-                    probed[s] = 1;
-                }
-            }
-
-            // Deprecation warning
-            if (warn && loaded)
-            {
-                string location = Path.GetFileNameWithoutExtension(lastAssembly.Location);
-                string deprWarning = "The module was found, but not in a referenced namespace.\n" +
-                                     $"Implicit loading is deprecated. Please use clr.AddReference('{location}').";
-                Exceptions.deprecation(deprWarning);
-            }
-
-            return loaded;
-        }
-
-
         /// <summary>
         /// Scans an assembly for exported namespaces, adding them to the
         /// mapping of valid namespaces. Note that for a given namespace
diff --git a/src/runtime/importhook.cs b/src/runtime/importhook.cs
@@ -310,38 +310,6 @@ public static IntPtr __import__(IntPtr self, IntPtr args, IntPtr kw)
 
             string[] names = realname.Split('.');
 
-            // Now we need to decide if the name refers to a CLR module,
-            // and may have to do an implicit load (for b/w compatibility)
-            // using the AssemblyManager. The assembly manager tries
-            // really hard not to use Python objects or APIs, because
-            // parts of it can run recursively and on strange threads.
-            //
-            // It does need an opportunity from time to time to check to
-            // see if sys.path has changed, in a context that is safe. Here
-            // we know we have the GIL, so we'll let it update if needed.
-
-            AssemblyManager.UpdatePath();
-            if (!AssemblyManager.IsValidNamespace(realname))
-            {
-                var loadExceptions = new List<Exception>();
-                if (!AssemblyManager.LoadImplicit(realname, assemblyLoadErrorHandler: loadExceptions.Add))
-                {
-                    // May be called when a module being imported imports a module.
-                    // In particular, I've seen decimal import copy import org.python.core
-                    IntPtr importResult = Runtime.PyObject_Call(py_import, args, kw);
-                    // TODO: use ModuleNotFoundError in Python 3.6+
-                    if (importResult == IntPtr.Zero && loadExceptions.Count > 0
-                        && Exceptions.ExceptionMatches(Exceptions.ImportError))
-                    {
-                        loadExceptions.Add(new PythonException());
-                        var importError = new PyObject(new BorrowedReference(Exceptions.ImportError));
-                        importError.SetAttr("__cause__", new AggregateException(loadExceptions).ToPython());
-                        Runtime.PyErr_SetObject(new BorrowedReference(Exceptions.ImportError), importError.Reference);
-                    }
-                    return importResult;
-                }
-            }
-
             // See if sys.modules for this interpreter already has the
             // requested module. If so, just return the existing module.
             IntPtr modules = Runtime.PyImport_GetModuleDict();
diff --git a/src/runtime/moduleobject.cs b/src/runtime/moduleobject.cs
@@ -118,30 +118,6 @@ public ManagedType GetAttribute(string name, bool guess)
                 return c;
             }
 
-            // This is a little repetitive, but it ensures that the right
-            // thing happens with implicit assembly loading at a reasonable
-            // cost. Ask the AssemblyManager to do implicit loading for each
-            // of the steps in the qualified name, then try it again.
-            bool ignore = name.StartsWith("__");
-            if (AssemblyManager.LoadImplicit(qname, assemblyLoadErrorHandler: ImportWarning, !ignore))
-            {
-                if (AssemblyManager.IsValidNamespace(qname))
-                {
-                    m = new ModuleObject(qname);
-                    StoreAttribute(name, m);
-                    m.DecrRefCount();
-                    return m;
-                }
-
-                type = AssemblyManager.LookupTypes(qname).FirstOrDefault(t => t.IsPublic);
-                if (type != null)
-                {
-                    c = ClassManager.GetClass(type);
-                    StoreAttribute(name, c);
-                    return c;
-                }
-            }
-
             // We didn't find the name, so we may need to see if there is a
             // generic type with this base name. If so, we'll go ahead and
             // return it. Note that we store the mapping of the unmangled
