Extend AttributeError suggestions to type-object (static and enum) misses

A missing attribute on a reflected type object -- a mistyped static member or
enum value such as DayOfWeek.Sundey -- previously raised the bare CPython
"type object 'X' has no attribute 'Y'" with no hint, because the miss hook was
installed on reflected types (governing their instances) but type-object access
is governed by the CLR metatype.

Install the same miss-only __getattr__ hook on the CLR metatype (allowing the
redirect when tp_getattro is type_getattro, not just the generic getattr), so a
type-object miss is enriched the same way instance misses are. BuildMissing
AttributeMessage now resolves the target from either a CLRObject (instance) or a
ClassBase (type object) and uses CPython's "type object 'T'" wording for the
latter.

Suggestions reuse the existing ranking/cache and the snake_case convention
Python exposes members under (ToSnakeCaseMemberName): methods become lower_snake
while enum values, consts and static-readonly members become UPPER_SNAKE, e.g.
DayOfWeek.Sundey -> "Did you mean: 'SUNDAY'?", Math.PII -> 'PI', String.Empy ->
'EMPTY'. All suggested names resolve. Hits, imports and hasattr on type objects
are unaffected (the hook is miss-only).

Adds tests for enum, static const, static-readonly field and static method
misses, the no-similar case and hasattr, in test_enum.py and test_class.py.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jhonabreul

src/runtime/AttributeErrorHint.cs

@@ -40,6 +40,10 @@ internal static class AttributeErrorHint
         private static IntPtr _hookSlot;
         // Address of PyObject_GenericGetAttr, used to detect types we may safely redirect.
         private static IntPtr _genericGetAttr;
+        // Address of type_getattro (PyType_Type.tp_getattro). The CLR metatype uses it, so we
+        // allow redirecting it too: that is how attribute access on a reflected type object
+        // (static members, enum values) gets the miss hook.
+        private static IntPtr _typeGetAttro;
 
         private static bool IsReady => _methodDef != IntPtr.Zero && _hookSlot != IntPtr.Zero;
 
@@ -48,6 +52,7 @@ internal static void Initialize()
             try
             {
                 _genericGetAttr = Util.ReadIntPtr(Runtime.PyBaseObjectType, TypeOffset.tp_getattro);
+                _typeGetAttro = Util.ReadIntPtr(Runtime.PyTypeType, TypeOffset.tp_getattro);
 
                 if (_methodDef == IntPtr.Zero)
                 {
@@ -70,6 +75,11 @@ internal static void Initialize()
 
                 using var probe = globals["__clr_getattr_probe__"];
                 _hookSlot = Util.ReadIntPtr(probe.Reference, TypeOffset.tp_getattro);
+
+                // Install the hook on the CLR metatype so that a miss on a reflected type
+                // object's own attribute (a mistyped static member or enum value, e.g.
+                // DayOfWeek.Sundey) is enriched the same way instance attribute misses are.
+                Install(MetaType.ClrMetaTypeReference);
             }
             catch (Exception e)
             {
@@ -94,7 +104,12 @@ internal static void Install(BorrowedReference type)
                 return;
             }
 
-            if (Util.ReadIntPtr(type, TypeOffset.tp_getattro) != _genericGetAttr)
+            var getattro = Util.ReadIntPtr(type, TypeOffset.tp_getattro);
+            // Only redirect types that still use one of the standard lookups: instances use the
+            // generic getattr, the CLR metatype uses type_getattro. Types with a custom
+            // tp_getattro (dynamic objects, modules, interfaces, ...) handle misses themselves
+            // and are left untouched.
+            if (getattro != _genericGetAttr && getattro != _typeGetAttro)
             {
                 return;
             }
@@ -158,6 +173,7 @@ internal static void Shutdown()
             // are reused by the next Initialize.
             _hookSlot = IntPtr.Zero;
             _genericGetAttr = IntPtr.Zero;
+            _typeGetAttro = IntPtr.Zero;
         }
     }
 }

src/runtime/Types/ClassBase.cs

@@ -35,10 +35,10 @@ internal class ClassBase : ManagedType, IDeserializationCallback
         private static readonly ConcurrentDictionary<Type, HashSet<string>> _candidateNameCache = new();
 
         // A miss-heavy workload probes the same missing names over and over (e.g. a per-bar
-        // getattr(self, "_optional", None) on a .NET-derived object). Memoize the fully-built
-        // " Did you mean: ...?" hint (empty when there is nothing to suggest) per
-        // (type, missing-name) so repeats are a dictionary lookup instead of an O(members)
-        // reflection + Levenshtein scan on every miss.
+        // getattr(self, "_optional", None) on a .NET-derived object, or a mistyped enum value).
+        // Memoize the fully-built " Did you mean: ...?" hint (empty when there is nothing to
+        // suggest) per (type, missing-name) so repeats are a dictionary lookup instead of an
+        // O(members) reflection + Levenshtein scan on every miss.
         private static readonly ConcurrentDictionary<(Type Type, string Name), string> _suggestionCache = new();
 
         internal ClassBase(Type tp)
@@ -676,26 +676,61 @@ internal static void AppendAttributeErrorSuggestions(BorrowedReference ob, Borro
         /// </summary>
         internal static string BuildMissingAttributeMessage(PyObject self, string name)
         {
-            var typeName = "object";
             try
             {
-                using var pyType = self.GetPythonType();
-                typeName = pyType.Name;
+                if (TryGetSuggestionTarget(self.Reference, out var type, out var staticScope))
+                {
+                    // Match CPython's wording: instances say "'T' object ...", whereas an access
+                    // on the type object itself (a missing static member or enum value) says
+                    // "type object 'T' ...".
+                    var baseMessage = staticScope
+                        ? $"type object '{type!.Name}' has no attribute '{name}'"
+                        : $"'{PythonTypeName(self)}' object has no attribute '{name}'";
+                    return baseMessage + GetSuggestionHint(type!, name);
+                }
             }
             catch
             {
-                // fall back to the generic type name
+                // never let message building turn into a different exception
             }
 
-            var message = $"'{typeName}' object has no attribute '{name}'";
+            return $"'{PythonTypeName(self)}' object has no attribute '{name}'";
+        }
+
+        private static string PythonTypeName(PyObject self)
+        {
             try
             {
-                return message + GetSuggestionHint(self.Reference, name);
+                using var pyType = self.GetPythonType();
+                return pyType.Name;
             }
             catch
             {
-                // never let suggestion building turn into a different exception
-                return message;
+                return "object";
+            }
+        }
+
+        /// <summary>
+        /// Resolves the managed <see cref="Type"/> whose members should be searched for a
+        /// missing-attribute suggestion, and whether the access was on the type object itself
+        /// (<paramref name="staticScope"/> = true, for static members and enum values) rather
+        /// than on an instance. Returns false for objects that are not reflected .NET types.
+        /// </summary>
+        private static bool TryGetSuggestionTarget(BorrowedReference ob, out Type? type, out bool staticScope)
+        {
+            type = null;
+            staticScope = false;
+            switch (GetManagedObject(ob))
+            {
+                case CLRObject clrObj when clrObj.inst is not null:
+                    type = clrObj.inst.GetType();
+                    return true;
+                case ClassBase classBase when classBase.type.Valid:
+                    type = classBase.type.Value;
+                    staticScope = true;
+                    return true;
+                default:
+                    return false;
             }
         }
 
@@ -707,19 +742,27 @@ internal static string BuildMissingAttributeMessage(PyObject self, string name)
         /// </summary>
         private static string GetSuggestionHint(BorrowedReference ob, string name)
         {
-            if (string.IsNullOrEmpty(name) || name.StartsWith("__", StringComparison.Ordinal))
+            if (!TryGetSuggestionTarget(ob, out var type, out _))
             {
                 return string.Empty;
             }
 
-            if (GetManagedObject(ob) is not CLRObject clrObj || clrObj.inst is null)
+            return GetSuggestionHint(type!, name);
+        }
+
+        private static string GetSuggestionHint(Type type, string name)
+        {
+            if (string.IsNullOrEmpty(name) || name.StartsWith("__", StringComparison.Ordinal))
             {
                 return string.Empty;
             }
 
-            // The hint is built and cached once per (type, name); on a repeated miss this is
-            // just a dictionary lookup. An empty string means there was nothing to suggest.
-            return _suggestionCache.GetOrAdd((clrObj.inst.GetType(), name),
+            // The hint is built and cached once per (type, name); on a repeated miss this is just
+            // a dictionary lookup. An empty string means there was nothing to suggest. The
+            // suggested names use the same snake_case convention Python exposes members under
+            // (see ToSnakeCaseMemberName), so they are independent of whether the access was on
+            // an instance or the type object.
+            return _suggestionCache.GetOrAdd((type, name),
                 static key => ComputeSimilarMemberNames(key.Type, key.Name));
         }
 
@@ -742,8 +785,12 @@ private static string GetErrorMessage(BorrowedReference value, string fallbackNa
             return $"object has no attribute '{fallbackName}'";
         }
 
-        // The deduplicated snake_case member names of a type, cached so the reflection and
-        // string conversion happen at most once per type rather than on every attribute miss.
+        // The snake_case candidate member names of a type, cached so the reflection and name
+        // conversion happen at most once per type rather than on every attribute miss. Instance
+        // and static members are both included, and each is converted with ToSnakeCaseMemberName
+        // so the suggestion matches the name Python exposes it under: methods become lower_snake,
+        // while enum values, consts and static-readonly members become UPPER_SNAKE (e.g.
+        // DayOfWeek.SUNDAY, Math.PI, String.EMPTY).
         private static HashSet<string> GetCandidateMemberNames(Type type)
         {
             return _candidateNameCache.GetOrAdd(type, static t =>
@@ -766,8 +813,6 @@ private static HashSet<string> GetCandidateMemberNames(Type type)
                         continue;
                     }
 
-                    // Suggest the snake_case alias, since that is the fork's PEP8-style
-                    // public API surface (members are exposed in both Pascal and snake case).
                     names.Add(ToSnakeCaseMemberName(member));
                 }
 

src/runtime/Types/MetaType.cs

@@ -26,6 +26,13 @@ internal sealed class MetaType : ManagedType
             "__subclasscheck__",
         };
 
+        /// <summary>
+        /// The CLR metatype object. Reflected .NET types are instances of it, so wiring the
+        /// AttributeError miss hook here enriches misses on a type object's own attributes
+        /// (static members and enum values).
+        /// </summary>
+        internal static BorrowedReference ClrMetaTypeReference => PyCLRMetaType.Reference;
+
         /// <summary>
         /// Metatype initialization. This bootstraps the CLR metatype to life.
         /// </summary>

tests/test_class.py

@@ -123,6 +123,66 @@ def test_missing_attribute_hasattr_still_false():
     assert hasattr(s, "Length")
 
 
+def test_missing_static_method_suggests_similar():
+    """A mistyped static method on a type object suggests the similar member."""
+    from System import Math
+
+    with pytest.raises(AttributeError) as exc_info:
+        _ = Math.Sqrtt
+
+    message = str(exc_info.value)
+    assert "type object 'Math'" in message
+    assert "Sqrtt" in message
+    assert "Did you mean" in message
+    # Methods are exposed lower_snake, so the suggestion is 'sqrt'. Quoted so the assertion
+    # matches the suggestion, not the typo 'Sqrtt'.
+    assert "'sqrt'" in message
+
+
+def test_missing_static_const_suggests_similar():
+    """A mistyped static const (Math.PI) suggests the UPPER_SNAKE constant name."""
+    from System import Math
+
+    with pytest.raises(AttributeError) as exc_info:
+        _ = Math.PII
+
+    message = str(exc_info.value)
+    assert "Did you mean" in message
+    # Consts are exposed UPPER_SNAKE; quoted so it matches the suggestion, not the typo 'PII'.
+    assert "'PI'" in message
+
+
+def test_missing_static_field_suggests_similar():
+    """A mistyped static-readonly field (String.Empty) suggests the UPPER_SNAKE name."""
+    with pytest.raises(AttributeError) as exc_info:
+        _ = System.String.Empy
+
+    message = str(exc_info.value)
+    assert "Did you mean" in message
+    # static-readonly fields are exposed UPPER_SNAKE -> String.EMPTY.
+    assert "'EMPTY'" in message
+
+
+def test_missing_static_member_no_similar():
+    """A static member with no similar name keeps the standard message (no hint)."""
+    from System import Math
+
+    with pytest.raises(AttributeError) as exc_info:
+        _ = Math.Zzzzzz
+
+    message = str(exc_info.value)
+    assert "Zzzzzz" in message
+    assert "Did you mean" not in message
+
+
+def test_missing_static_member_hasattr_still_false():
+    """The type-object miss hook must not break hasattr() on a type."""
+    from System import Math
+
+    assert hasattr(Math, "Sqrt")
+    assert not hasattr(Math, "Sqrtt")
+
+
 def test_missing_attribute_hook_is_native():
     """The __getattr__ hook must be a native method descriptor.
 

tests/test_enum.py

@@ -31,6 +31,43 @@ def test_enum_get_member():
     assert DayOfWeek.Saturday == DayOfWeek(6)
 
 
+def test_missing_enum_member_suggests_similar():
+    """A mistyped enum member suggests the correct member by its .NET name."""
+    from System import DayOfWeek
+
+    with pytest.raises(AttributeError) as exc_info:
+        _ = DayOfWeek.Sundey
+
+    message = str(exc_info.value)
+    # Access on the type object itself uses the "type object 'T'" wording.
+    assert "type object 'DayOfWeek'" in message
+    assert "Sundey" in message
+    assert "Did you mean" in message
+    # Enum values are exposed in UPPER_SNAKE (the fork's PEP8 constant convention), so that is
+    # the form suggested -- DayOfWeek.SUNDAY, not 'Sunday'.
+    assert "'SUNDAY'" in message
+
+
+def test_missing_enum_member_no_similar():
+    """An enum member with no similar name keeps the standard message (no hint)."""
+    from System import DayOfWeek
+
+    with pytest.raises(AttributeError) as exc_info:
+        _ = DayOfWeek.Xyzzy
+
+    message = str(exc_info.value)
+    assert "Xyzzy" in message
+    assert "Did you mean" not in message
+
+
+def test_missing_enum_member_hasattr_still_false():
+    """Enriching the AttributeError must not break hasattr() on enum types."""
+    from System import DayOfWeek
+
+    assert hasattr(DayOfWeek, "Sunday")
+    assert not hasattr(DayOfWeek, "Sundey")
+
+
 def test_byte_enum():
     """Test byte enum."""
     assert Test.ByteEnum.Zero == Test.ByteEnum(0)