Oct 1, 2021 · Oct 1, 2021
diff --git a/src/embed_tests/ClassManagerTests.cs b/src/embed_tests/ClassManagerTests.cs
 using NUnit.Framework;

 using Python.Runtime;

 namespace Python.EmbeddingTest
 {
    public class ClassManagerTests
    {
        [OneTimeSetUp]
        public void SetUp()
        {
            PythonEngine.Initialize();
        }

        [OneTimeTearDown]
        public void Dispose()
        {
            PythonEngine.Shutdown();
        }

        [Test]
        public void NestedClassDerivingFromParent()
        {
            var f = new NestedTestContainer().ToPython();
            f.GetAttr(nameof(NestedTestContainer.Bar));
        }
    }

    public class NestedTestParent
    {
        public class Nested : NestedTestParent
        {
        }
    }

    public class NestedTestContainer
    {
        public NestedTestParent Bar = new NestedTestParent.Nested();
    }
 }
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Linq;

 namespace Python.Runtime
 {
                    invalidClasses.Add(pair);
                    continue;
                }
                // Ensure, that matching Python type exists first.
                // It is required for self-referential classes
                // (e.g. with members, that refer to the same class)
                var pyType = InitPyType(pair.Key.Value, pair.Value);
                // re-init the class
                InitClassBase(pair.Key.Value, pair.Value);
                InitClassBase(pair.Key.Value, pair.Value, pyType);
                // We modified the Type object, notify it we did.
                Runtime.PyType_Modified(pair.Value.TypeReference);
                var context = contexts[pair.Value.pyHandle];
            }
            cb = CreateClass(type);
            cache.Add(type, cb);
            // Ensure, that matching Python type exists first.
            // It is required for self-referential classes
            // (e.g. with members, that refer to the same class)
            var pyType = InitPyType(type, cb);
            // Initialize the object later, as this might call this GetClass method
            // recursively (for example when a nested class inherits its declaring class...)
            InitClassBase(type, cb);
            InitClassBase(type, cb, pyType);
            return cb;
        }

            return impl;
        }

        private staticvoid InitClassBase(Type type, ClassBase impl)
        private staticPyType InitPyType(Type type, ClassBase impl)
        {
            // Ensure, that matching Python type exists first.
            // It is required for self-referential classes
            // (e.g. with members, that refer to the same class)
            var pyType = TypeManager.GetOrCreateClass(type);

            // Set the handle attributes on the implementing instance.
            impl.tpHandle = impl.pyHandle = pyType.Handle;

            return pyType;
        }

        private static void InitClassBase(Type type, ClassBase impl, PyType pyType)
        {
            // First, we introspect the managed type and build some class
            // information, including generating the member descriptors
            // that we'll be putting in the Python class __dict__.
                        }
                        // Note the given instance might be uninitialized
                        ob = GetClass(tp);
                        if (ob.pyHandle == IntPtr.Zero && ob is ClassObject)
                        {
                            ob.pyHandle = ob.tpHandle = TypeManager.GetOrCreateClass(tp).Handle;
                        }
                        Debug.Assert(ob.pyHandle != IntPtr.Zero);
                        // GetClass returns a Borrowed ref. ci.members owns the reference.
                        ob.IncrRefCount();
                        ci.members[mi.Name] = ob;
diff --git a/src/runtime/typemanager.cs b/src/runtime/typemanager.cs
        {
            if (!cache.TryGetValue(type, out var pyType))
            {
                pyType = CreateClass(type);
                pyType = AllocateClass(type);
                cache.Add(type, pyType);
                try
                {
                    InitializeClass(type, pyType);
                }
                catch
                {
                    cache.Remove(type);
                    throw;
                }
            }
            return pyType;
        }
        }


        staticPyType CreateClass(Type clrType)
        staticvoid InitializeClass(Type clrType, PyType pyType)
        {
            string name = GetPythonTypeName(clrType);
            if (pyType.BaseReference != null)
            {
                return;
            }

            using var baseTuple = GetBaseTypeTuple(clrType);

            InitializeBases(pyType, baseTuple);
            // core fields must be initialized in partially constructed classes,
            // otherwise it would be impossible to manipulate GCHandle and check type size
            InitializeCoreFields(pyType);
        }

        static PyType AllocateClass(Type clrType)
        {
            string name = GetPythonTypeName(clrType);

            IntPtr type = AllocateTypeObject(name, Runtime.PyCLRMetaType);
            var pyType = new PyType(StolenReference.DangerousFromPointer(type));
            pyType.Flags = TypeFlags.Default
                            | TypeFlags.BaseType
                            | TypeFlags.HaveGC;

            cache.Add(clrType, pyType);
            try
            {
                InitializeBases(pyType, baseTuple);
                // core fields must be initialized in partically constructed classes,
                // otherwise it would be impossible to manipulate GCHandle and check type size
                InitializeCoreFields(pyType);
            }
            catch
            {
                cache.Remove(clrType);
                throw;
            }

            return pyType;
        }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,40 @@
		using NUnit.Framework;

		using Python.Runtime;

		namespace Python.EmbeddingTest
		{
		public class ClassManagerTests
		{
		[OneTimeSetUp]
		public void SetUp()
		{
		PythonEngine.Initialize();
		}

		[OneTimeTearDown]
		public void Dispose()
		{
		PythonEngine.Shutdown();
		}

		[Test]
		public void NestedClassDerivingFromParent()
		{
		var f = new NestedTestContainer().ToPython();
		f.GetAttr(nameof(NestedTestContainer.Bar));
		}
		}

		public class NestedTestParent
		{
		public class Nested : NestedTestParent
		{
		}
		}

		public class NestedTestContainer
		{
		public NestedTestParent Bar = new NestedTestParent.Nested();
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -1,10 +1,11 @@
		using System;
		using System.Collections;
		using System.Collections.Generic;
		using System.Diagnostics;
		using System.Linq;
		using System.Reflection;
		using System.Runtime.InteropServices;
		using System.Security;
		using System.Linq;

		namespace Python.Runtime
		{
Expand DownExpand Up		@@ -151,8 +152,12 @@ internal static Dictionary<ManagedType, InterDomainContext> RestoreRuntimeData(R
		invalidClasses.Add(pair);
		continue;
		}
		// Ensure, that matching Python type exists first.
		// It is required for self-referential classes
		// (e.g. with members, that refer to the same class)
		var pyType = InitPyType(pair.Key.Value, pair.Value);
		// re-init the class
		InitClassBase(pair.Key.Value, pair.Value);
		InitClassBase(pair.Key.Value, pair.Value, pyType);
		// We modified the Type object, notify it we did.
		Runtime.PyType_Modified(pair.Value.TypeReference);
		var context = contexts[pair.Value.pyHandle];
Expand DownExpand Up		@@ -184,9 +189,13 @@ internal static ClassBase GetClass(Type type)
		}
		cb = CreateClass(type);
		cache.Add(type, cb);
		// Ensure, that matching Python type exists first.
		// It is required for self-referential classes
		// (e.g. with members, that refer to the same class)
		var pyType = InitPyType(type, cb);
		// Initialize the object later, as this might call this GetClass method
		// recursively (for example when a nested class inherits its declaring class...)
		InitClassBase(type, cb);
		InitClassBase(type, cb, pyType);
		return cb;
		}

Expand DownExpand Up		@@ -249,16 +258,18 @@ private static ClassBase CreateClass(Type type)
		return impl;
		}

		private staticvoid InitClassBase(Type type, ClassBase impl)
		private staticPyType InitPyType(Type type, ClassBase impl)
		{
		// Ensure, that matching Python type exists first.
		// It is required for self-referential classes
		// (e.g. with members, that refer to the same class)
		var pyType = TypeManager.GetOrCreateClass(type);

		// Set the handle attributes on the implementing instance.
		impl.tpHandle = impl.pyHandle = pyType.Handle;

		return pyType;
		}

		private static void InitClassBase(Type type, ClassBase impl, PyType pyType)
		{
		// First, we introspect the managed type and build some class
		// information, including generating the member descriptors
		// that we'll be putting in the Python class __dict__.
Expand DownExpand Up		@@ -549,6 +560,11 @@ private static ClassInfo GetClassInfo(Type type)
		}
		// Note the given instance might be uninitialized
		ob = GetClass(tp);
		if (ob.pyHandle == IntPtr.Zero && ob is ClassObject)
		{
		ob.pyHandle = ob.tpHandle = TypeManager.GetOrCreateClass(tp).Handle;
		}
		Debug.Assert(ob.pyHandle != IntPtr.Zero);
		// GetClass returns a Borrowed ref. ci.members owns the reference.
		ob.IncrRefCount();
		ci.members[mi.Name] = ob;
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -146,7 +146,17 @@ internal static PyType GetOrCreateClass(Type type)
		{
		if (!cache.TryGetValue(type, out var pyType))
		{
		pyType = CreateClass(type);
		pyType = AllocateClass(type);
		cache.Add(type, pyType);
		try
		{
		InitializeClass(type, pyType);
		}
		catch
		{
		cache.Remove(type);
		throw;
		}
		}
		return pyType;
		}
Expand DownExpand Up		@@ -209,12 +219,25 @@ internal static unsafe PyType CreateType(Type impl)
		}


		staticPyType CreateClass(Type clrType)
		staticvoid InitializeClass(Type clrType, PyType pyType)
		{
		string name = GetPythonTypeName(clrType);
		if (pyType.BaseReference != null)
		{
		return;
		}

		using var baseTuple = GetBaseTypeTuple(clrType);

		InitializeBases(pyType, baseTuple);
		// core fields must be initialized in partially constructed classes,
		// otherwise it would be impossible to manipulate GCHandle and check type size
		InitializeCoreFields(pyType);
		}

		static PyType AllocateClass(Type clrType)
		{
		string name = GetPythonTypeName(clrType);

		IntPtr type = AllocateTypeObject(name, Runtime.PyCLRMetaType);
		var pyType = new PyType(StolenReference.DangerousFromPointer(type));
		pyType.Flags = TypeFlags.Default
Expand All		@@ -223,20 +246,6 @@ static PyType CreateClass(Type clrType)
		\| TypeFlags.BaseType
		\| TypeFlags.HaveGC;

		cache.Add(clrType, pyType);
		try
		{
		InitializeBases(pyType, baseTuple);
		// core fields must be initialized in partically constructed classes,
		// otherwise it would be impossible to manipulate GCHandle and check type size
		InitializeCoreFields(pyType);
		}
		catch
		{
		cache.Remove(clrType);
		throw;
		}

		return pyType;
		}

Expand Down