py/obj: Fix MP_OBJ_TYPE_SET_SLOT_IF_EXISTS macro for MSVC compatibility.

The previous implementation used a do-while(0) pattern which MSVC doesn't
accept. Replace with a conditional expression using the comma operator
that works with both GCC and MSVC compilers.

This fixes Windows port compilation error C2121.

Signed-off-by: Andrew Leech <[email protected]>

Author: pi-anl

py/obj.h

@@ -805,12 +805,8 @@ typedef struct _mp_obj_full_type_t {
 #define MP_OBJ_TYPE_GET_SLOT(t, f) (_MP_OBJ_TYPE_SLOT_TYPE_##f(t)->slots[(t)->slot_index_##f - 1])
 #define MP_OBJ_TYPE_GET_SLOT_OR_NULL(t, f) (_MP_OBJ_TYPE_SLOT_TYPE_##f(MP_OBJ_TYPE_HAS_SLOT(t, f) ? MP_OBJ_TYPE_GET_SLOT(t, f) : NULL))
 #define MP_OBJ_TYPE_SET_SLOT(t, f, v, n) ((t)->slot_index_##f = (n) + 1, (t)->slots[(n)] = (void *)v)
-#define MP_OBJ_TYPE_SET_SLOT_IF_EXISTS(t, f, v, n) do { \
-        void *_v = (void *)(v); \
-        if (_v != NULL) { \
-            MP_OBJ_TYPE_SET_SLOT(t, f, _v, n); \
-        } \
-} while (0)
+#define MP_OBJ_TYPE_SET_SLOT_IF_EXISTS(t, f, v, n) \
+    ((v) ? (MP_OBJ_TYPE_SET_SLOT(t, f, v, n), (void)0) : (void)0)
 #define MP_OBJ_TYPE_OFFSETOF_SLOT(f) (offsetof(mp_obj_type_t, slot_index_##f))
 #define MP_OBJ_TYPE_HAS_SLOT_BY_OFFSET(t, offset) (*(uint8_t *)((char *)(t) + (offset)) != 0)
 

test_debug.py

@@ -5,35 +5,44 @@
 print("Testing type.__init__ access:")
 print(f"hasattr(type, '__init__'): {hasattr(type, '__init__')}")
 
+
 class CustomMeta(type):
     pass
 
+
 print(f"hasattr(CustomMeta, '__init__'): {hasattr(CustomMeta, '__init__')}")
 
+
 class RegularClass:
     pass
 
+
 print(f"hasattr(RegularClass, '__init__'): {hasattr(RegularClass, '__init__')}")
 
 # Test deep hierarchy
 print("\nTesting deep hierarchy:")
 init_order = []
 
+
 class Meta1(type):
     def __init__(cls, name, bases, attrs):
         print(f"Meta1.__init__ called for {name}")
         super().__init__(name, bases, attrs)
-        init_order.append('Meta1')
+        init_order.append("Meta1")
+
 
 class Meta2(Meta1):
     def __init__(cls, name, bases, attrs):
         print(f"Meta2.__init__ called for {name}")
         super().__init__(name, bases, attrs)
-        init_order.append('Meta2')
+        init_order.append("Meta2")
+
 
 try:
+
     class Test(metaclass=Meta2):
         pass
+
     print(f"init_order: {init_order}")
 except Exception as e:
-    print(f"Error creating Test: {e}")
+    print(f"Error creating Test: {e}")

test_metaclass_edge_cases.py

@@ -3,6 +3,7 @@
 
 import traceback
 
+
 def test_case(name, func):
     """Helper to run test cases and catch errors."""
     try:
@@ -14,21 +15,25 @@ def test_case(name, func):
         traceback.print_exc()
         return False
 
+
 # Test 1: Basic super().__init__() in metaclass
 def test_basic_metaclass_super():
     """The original crash scenario."""
+
     class Meta(type):
         def __init__(cls, name, bases, attrs):
             super().__init__(name, bases, attrs)
 
     class Test(metaclass=Meta):
         pass
 
-    assert Test.__name__ == 'Test'
+    assert Test.__name__ == "Test"
+
 
 # Test 2: Multiple inheritance in metaclass hierarchy
 def test_metaclass_multiple_inheritance():
     """Test metaclass with multiple inheritance."""
+
     class MetaA(type):
         def __init__(cls, name, bases, attrs):
             super().__init__(name, bases, attrs)
@@ -48,17 +53,19 @@ class Test(metaclass=MetaC):
         pass
 
     # MRO should be MetaC -> MetaA -> MetaB -> type
-    assert hasattr(Test, 'from_a')
-    assert hasattr(Test, 'from_c')
+    assert hasattr(Test, "from_a")
+    assert hasattr(Test, "from_c")
     # MetaB's __init__ may or may not be called depending on MRO implementation
 
+
 # Test 3: type.__init__ should accept exactly 1 or 4 arguments (MicroPython)
 #         or 1 or 3 arguments (CPython)
 def test_type_init_signature():
     """Verify type.__init__ signature."""
     # Test what signatures are accepted
     import sys
-    is_micropython = sys.implementation.name == 'micropython'
+
+    is_micropython = sys.implementation.name == "micropython"
 
     # 1 argument (just self) should work
     type.__init__(type)
@@ -69,49 +76,53 @@ class Meta(type):
 
     if is_micropython:
         # MicroPython: 4 arguments (self, name, bases, dict)
-        type.__init__(Meta, 'Test', (), {})
+        type.__init__(Meta, "Test", (), {})
         expected_msg = "takes 1 or 4 arguments"
     else:
         # CPython: 3 arguments (name, bases, dict) - self is implicit
-        type.__init__(Meta, 'Test', ())
+        type.__init__(Meta, "Test", ())
         expected_msg = "takes 1 or 3 arguments"
 
     # Other argument counts should fail
     try:
-        type.__init__(type, 'extra')
+        type.__init__(type, "extra")
         assert False, "Should have raised TypeError"
     except TypeError as e:
         assert expected_msg in str(e)
 
     try:
-        type.__init__(type, 'a', 'b', 'c', 'd', 'e')
+        type.__init__(type, "a", "b", "c", "d", "e")
         assert False, "Should have raised TypeError"
     except TypeError as e:
         assert expected_msg in str(e)
 
+
 # Test 4: Regular classes should NOT have type.__init__
 def test_regular_class_no_type_init():
     """Regular classes shouldn't expose type.__init__."""
+
     class RegularClass:
         pass
 
     # This depends on implementation details - in CPython, hasattr returns True
     # but the attribute lookup goes through descriptors
     # The key is that calling it shouldn't create a new type
-    if hasattr(RegularClass, '__init__'):
+    if hasattr(RegularClass, "__init__"):
         # If it exists, calling it with wrong args should behave correctly
         try:
             # This should either not be type.__init__ or should fail appropriately
-            result = RegularClass.__init__(RegularClass, 'name', (), {})
+            result = RegularClass.__init__(RegularClass, "name", (), {})
             # If it succeeded, it shouldn't have created a new type
             assert result is None or not isinstance(result, type)
         except TypeError:
             # Expected - regular class __init__ has different signature
             pass
 
+
 # Test 5: Custom metaclass with type as explicit base
 def test_explicit_type_base():
     """Test metaclass that explicitly inherits from type."""
+
     class Meta(type):
         def __init__(cls, name, bases, attrs):
             # Explicit call to type.__init__ instead of super()
@@ -121,23 +132,27 @@ def __init__(cls, name, bases, attrs):
     class Test(metaclass=Meta):
         pass
 
-    assert hasattr(Test, 'initialized')
+    assert hasattr(Test, "initialized")
     assert Test.initialized == True
 
+
 # Test 6: Metaclass without __init__ should work
 def test_metaclass_no_init():
     """Metaclass without __init__ should inherit type's."""
+
     class Meta(type):
         pass  # No __init__ defined
 
     class Test(metaclass=Meta):
         pass
 
-    assert Test.__name__ == 'Test'
+    assert Test.__name__ == "Test"
+
 
 # Test 7: Deep metaclass hierarchy
 def test_deep_metaclass_hierarchy():
     """Test deeply nested metaclass inheritance."""
+
     class Meta1(type):
         def __init__(cls, name, bases, attrs):
             super().__init__(name, bases, attrs)
@@ -160,9 +175,11 @@ class Test(metaclass=Meta3):
     assert Test.level2 == True
     assert Test.level3 == True
 
+
 # Test 8: super() in metaclass without __init__ override
 def test_super_in_other_metaclass_method():
     """Test super() in metaclass methods other than __init__."""
+
     class Meta(type):
         def custom_method(cls):
             # This should work - super() in non-__init__ context
@@ -172,24 +189,27 @@ class Test(metaclass=Meta):
         pass
 
     # This tests that super() works in other contexts
-    assert Test.custom_method() == 'Test'
+    assert Test.custom_method() == "Test"
+
 
 # Test 9: type.__init__ should be a no-op
 def test_type_init_is_noop():
     """Verify type.__init__ doesn't modify anything."""
+
     class Meta(type):
         pass
 
     # Create a class normally
-    Test1 = Meta('Test1', (), {'x': 1})
+    Test1 = Meta("Test1", (), {"x": 1})
 
     # Call type.__init__ again - should be no-op
-    type.__init__(Test1, 'DifferentName', (), {'y': 2})
+    type.__init__(Test1, "DifferentName", (), {"y": 2})
 
     # Name and attributes should be unchanged
-    assert Test1.__name__ == 'Test1'
-    assert hasattr(Test1, 'x')
-    assert not hasattr(Test1, 'y')
+    assert Test1.__name__ == "Test1"
+    assert hasattr(Test1, "x")
+    assert not hasattr(Test1, "y")
+
 
 # Test 10: Verify the fix doesn't break instance __init__
 def test_instance_init_still_works():
@@ -198,29 +218,30 @@ def test_instance_init_still_works():
 
     class Base:
         def __init__(self):
-            init_called.append('Base')
+            init_called.append("Base")
 
     class Derived(Base):
         def __init__(self):
             super().__init__()
-            init_called.append('Derived')
+            init_called.append("Derived")
 
     obj = Derived()
-    assert init_called == ['Base', 'Derived']
+    assert init_called == ["Base", "Derived"]
+
 
 # Run all tests
-if __name__ == '__main__':
+if __name__ == "__main__":
     tests = [
-        ('Basic metaclass super().__init__', test_basic_metaclass_super),
-        ('Metaclass multiple inheritance', test_metaclass_multiple_inheritance),
-        ('type.__init__ signature', test_type_init_signature),
-        ('Regular class no type.__init__', test_regular_class_no_type_init),
-        ('Explicit type base', test_explicit_type_base),
-        ('Metaclass without __init__', test_metaclass_no_init),
-        ('Deep metaclass hierarchy', test_deep_metaclass_hierarchy),
-        ('super() in other methods', test_super_in_other_metaclass_method),
-        ('type.__init__ is no-op', test_type_init_is_noop),
-        ('Instance __init__ still works', test_instance_init_still_works),
+        ("Basic metaclass super().__init__", test_basic_metaclass_super),
+        ("Metaclass multiple inheritance", test_metaclass_multiple_inheritance),
+        ("type.__init__ signature", test_type_init_signature),
+        ("Regular class no type.__init__", test_regular_class_no_type_init),
+        ("Explicit type base", test_explicit_type_base),
+        ("Metaclass without __init__", test_metaclass_no_init),
+        ("Deep metaclass hierarchy", test_deep_metaclass_hierarchy),
+        ("super() in other methods", test_super_in_other_metaclass_method),
+        ("type.__init__ is no-op", test_type_init_is_noop),
+        ("Instance __init__ still works", test_instance_init_still_works),
     ]
 
     passed = 0
@@ -232,9 +253,9 @@ def __init__(self):
         else:
             failed += 1
 
-    print(f"\n{'='*50}")
+    print(f"\n{'=' * 50}")
     print(f"Results: {passed} passed, {failed} failed")
     if failed == 0:
         print("All tests PASSED!")
     else:
-        print(f"Some tests FAILED!")
+        print(f"Some tests FAILED!")

test_metaclass_inheritance.py

@@ -3,18 +3,22 @@
 # Test inherited metaclass __init__
 init_calls = []
 
+
 class BaseMeta(type):
     def __init__(cls, name, bases, attrs):
         super().__init__(name, bases, attrs)
         init_calls.append(f"BaseMeta.__init__({name})")
         print(f"BaseMeta.__init__({name})")
 
+
 class DerivedMeta(BaseMeta):
     pass  # No __init__ in this class's dict
 
+
 class TestClass(metaclass=DerivedMeta):
     pass
 
+
 print(f"\nInit calls: {init_calls}")
 print(f"Expected: ['BaseMeta.__init__(TestClass)']")
 print(f"Pass: {init_calls == ['BaseMeta.__init__(TestClass)']}")