[ty] Add attribute assignment tests for unions

Author: thejchap

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -74,7 +74,7 @@ reveal_type(c_instance.declared_and_bound)  # revealed: bool
 
 #### Variable declared in class body and possibly bound in `__init__`
 
-The same rule applies even if the variable is *declared* (not bound!) in the class body: it is still
+The same rule applies even if the variable is _declared_ (not bound!) in the class body: it is still
 a pure instance variable.
 
 ```py
@@ -780,7 +780,7 @@ reveal_type(c_instance.variable_with_class_default1)  # revealed: str
 #### Descriptor attributes as class variables
 
 Whether they are explicitly qualified as `ClassVar`, or just have a class level default, we treat
-descriptor attributes as class variables. This test mainly makes sure that we do *not* treat them as
+descriptor attributes as class variables. This test mainly makes sure that we do _not_ treat them as
 instance variables. This would lead to a different outcome, since the `__get__` method would not be
 called (the descriptor protocol is not invoked for instance variables).
 
@@ -897,7 +897,7 @@ def _(flag: bool):
     reveal_type(C3.attr2)  # revealed: Literal["metaclass value", "class value"]
 ```
 
-If the *metaclass* attribute is only partially defined, we emit a `possibly-unbound-attribute`
+If the _metaclass_ attribute is only partially defined, we emit a `possibly-unbound-attribute`
 diagnostic:
 
 ```py
@@ -1400,7 +1400,7 @@ def _(a_and_b: Intersection[A, B]):
 
 The union of the set of types that `Any` could materialise to is equivalent to `object`. It follows
 from this that attribute access on `Any` resolves to `Any` if the attribute does not exist on
-`object` -- but if the attribute *does* exist on `object`, the type of the attribute is
+`object` -- but if the attribute _does_ exist on `object`, the type of the attribute is
 `<type as it exists on object> & Any`.
 
 ```py
@@ -1628,6 +1628,70 @@ date.year = 2025
 date.tz = "UTC"
 ```
 
+### Setting attributes on unions
+
+Setting attributes on unions where all elements of the union have the attribute is acceptable
+
+```py
+from typing import Union
+
+class A:
+    x: int
+
+class B:
+    x: int
+
+C = Union[A, B]
+
+a: C = A()
+a.x = 42
+```
+
+Setting attributes on unions where any element of the union does not have the attribute reports
+possibly unbound
+
+```py
+from typing import Union
+
+class A:
+    pass
+
+class B:
+    x: int
+
+C = Union[A, B]
+
+a: C = A()
+
+# instead of unresolved-attribute, this should report possibly-unbound-attribute
+# TODO: error: [possibly-unbound-attribute]
+# error: [unresolved-attribute]
+a.x = 42
+
+a: C = B()
+
+# TODO: error: [possibly-unbound-attribute]
+a.x = 42
+```
+
+Setting attributes on a generic where the upper bound is a union, and not all elements of the union
+have the attribute, also reports possibly unbound:
+
+```py
+from typing import Union, TypeVar
+
+class A:
+    pass
+
+class B:
+    x: int
+
+C = TypeVar("C", bound=Union[A, B])
+
+def _(a: C):
+    a.x = 42  # error: [possibly-unbound-attribute]
+```
+
 ### `argparse.Namespace`
 
 A standard library example of a class with a custom `__setattr__` method is `argparse.Namespace`:
@@ -1732,11 +1796,13 @@ for mod.global_symbol in IntIterable():
 `outer/__init__.py`:
 
 ```py
+
 ```
 
 `outer/nested/__init__.py`:
 
 ```py
+
 ```
 
 `outer/nested/inner.py`:
@@ -2111,7 +2177,7 @@ reveal_type(Foo.__members__)  # revealed: @Todo(Attribute access on enum classes
 
 ## References
 
-Some of the tests in the *Class and instance variables* section draw inspiration from
+Some of the tests in the _Class and instance variables_ section draw inspiration from
 [pyright's documentation] on this topic.
 
 [descriptor protocol tests]: descriptor_protocol.md