[ty] Add hint if async context manager is used in non-async with statement

crates/ty_python_semantic/resources/mdtest/snapshots/sync.md_-_With_statements_-_Context_manager_with…_(380131e1948d8d01).snap

@@ -0,0 +1,85 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: sync.md - With statements - Context manager with `__aenter__` and `__aexit__`
+mdtest path: crates/ty_python_semantic/resources/mdtest/with/sync.md
+---
+
+# Python source files
+
+## mdtest_snippet.py
+
+```
+ 1 | class Manager:
+ 2 |     async def __aenter__(self): ...
+ 3 |     async def __aexit__(self, *args): ...
+ 4 | 
+ 5 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+ 6 | with Manager():
+ 7 |     ...
+ 8 | class Manager:
+ 9 |     async def __aenter__(self): ...
+10 |     async def __aexit__(self, exc_type: str, exc_value, traceback): ...
+11 | 
+12 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+13 | with Manager():
+14 |     ...
+15 | class Manager:
+16 |     async def __aenter__(self): ...
+17 |     async def __aexit__(self, exc_type, exc_value, traceback, wrong_extra_arg): ...
+18 | 
+19 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+20 | with Manager():
+21 |     ...
+```
+
+# Diagnostics
+
+```
+error[invalid-context-manager]: Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`
+ --> src/mdtest_snippet.py:6:6
+  |
+5 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and...
+6 | with Manager():
+  |      ^^^^^^^^^
+7 |     ...
+8 | class Manager:
+  |
+info: Objects of type `Manager` can be used as async context managers
+info: Consider using `async with` here
+info: rule `invalid-context-manager` is enabled by default
+
+```
+
+```
+error[invalid-context-manager]: Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`
+  --> src/mdtest_snippet.py:13:6
+   |
+12 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` an...
+13 | with Manager():
+   |      ^^^^^^^^^
+14 |     ...
+15 | class Manager:
+   |
+info: Objects of type `Manager` can be used as async context managers
+info: Consider using `async with` here
+info: rule `invalid-context-manager` is enabled by default
+
+```
+
+```
+error[invalid-context-manager]: Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`
+  --> src/mdtest_snippet.py:20:6
+   |
+19 | # error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` an...
+20 | with Manager():
+   |      ^^^^^^^^^
+21 |     ...
+   |
+info: Objects of type `Manager` can be used as async context managers
+info: Consider using `async with` here
+info: rule `invalid-context-manager` is enabled by default
+
+```

crates/ty_python_semantic/resources/mdtest/with/sync.md

@@ -149,3 +149,45 @@ context_expr = Manager()
 with context_expr as f:
     reveal_type(f)  # revealed: str
 ```
+
+## Context manager with `__aenter__` and `__aexit__`
+
+<!-- snapshot-diagnostics -->
+
+If `__aenter__` and `__aexit__` are implemented, then the `async with` is probably the intentional
+usage. We then add a sub-diagnosis to hint the user to use `async with`.
+
+```py
+class Manager:
+    async def __aenter__(self): ...
+    async def __aexit__(self, *args): ...
+
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+with Manager():
+    ...
+```
+
+The sub-diagnosis is also provided if the user did not type annotated properly `__enter__` or/and
+`__exit__`.
+
+```py
+class Manager:
+    async def __aenter__(self): ...
+    async def __aexit__(self, exc_type: str, exc_value, traceback): ...
+
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+with Manager():
+    ...
+```
+
+Or if the user did not use the proper arguments for `__enter__` or/and `__exit__`.
+
+```py
+class Manager:
+    async def __aenter__(self): ...
+    async def __aexit__(self, exc_type, exc_value, traceback, wrong_extra_arg): ...
+
+# error: [invalid-context-manager] "Object of type `Manager` cannot be used with `with` because it does not implement `__enter__` and `__exit__`"
+with Manager():
+    ...
+```

crates/ty_python_semantic/src/types.rs

@@ -6051,12 +6051,29 @@ impl<'db> ContextManagerError<'db> {
             } => format_call_dunder_errors(enter_error, "__enter__", exit_error, "__exit__"),
         };
 
-        builder.into_diagnostic(
+        let mut diag = builder.into_diagnostic(
             format_args!(
                 "Object of type `{context_expression}` cannot be used with `with` because {formatted_errors}",
                 context_expression = context_expression_type.display(db)
             ),
         );
+
+        // If `__aenter__` and `__aexit__` are implemented, using `async with` was maybe the intention here.
+        if let (Ok(_) | Err(CallDunderError::CallError(..)), Ok(_))
+        | (Ok(_), Err(CallDunderError::CallError(..))) = (
+            context_expression_type.try_call_dunder(db, "__aenter__", CallArgumentTypes::none()),
+            context_expression_type.try_call_dunder(
+                db,
+                "__aexit__",
+                CallArgumentTypes::positional([Type::unknown(), Type::unknown(), Type::unknown()]),
+            ),
+        ) {
+            diag.info(format_args!(
+                "Objects of type `{context_expression}` can be used as async context managers",
+                context_expression = context_expression_type.display(db)
+            ));
+            diag.info("Consider using `async with` here");
+        }
     }
 }