Report one bad-context-manager error per broken with-item

Summary:
Fixes #5079

## Problem

A context manager that fails **both** protocol halves produced two `bad-context-manager` errors with an identical header and range:

```python
from contextlib import asynccontextmanager

asynccontextmanager
async def async_context():
    yield

with async_context():  # TWO identical errors appear here
    print("This will cause an error at runtime")
```

Both errors read "Cannot use `_AsyncGeneratorContextManager[None]` as a context manager"; they differ only in the detail line (`__enter__` vs `__exit__` missing). The error collector intentionally does not merge diagnostics whose details differ, so the pair always displayed.

## Change

`context_value` checks the protocol in two halves (enter, exit), each attributing failures to the with-item's range under the shared `bad-context-manager` context. Each half's diagnostics are now collected in their own delayed collector, and only the **first failing half's** errors are forwarded:

- enter broken → the enter error survives (it carries the actionable "Did you mean `__aenter__`?" hint, which is exactly the fix a user needs for the issue's case);
- enter fine → exit errors forwarded byte-for-byte as before, including the existing two-call consolidation for bad `__exit__` signatures;
- the exit half is still fully evaluated so its return type keeps feeding the `bool | None` check.

An object failing only one half still yields exactly one error naming that half; `async with` on async context managers is unaffected.

X-link: #5095

Reviewed By: rchen152

Differential Revision: D123266669

fbshipit-source-id: 036daaf3c0383dbab4f28f76fe7b5997a0782d0d

Author: nitishagar

pyrefly/lib/alt/solve.rs

@@ -2149,10 +2149,31 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         self.distribute_over_union(context_manager_type, |context_manager_type| {
             let context =
                 || ErrorContext::BadContextManager(self.for_display(context_manager_type.clone()));
-            let enter_type =
-                self.context_value_enter(context_manager_type, kind, range, errors, Some(&context));
-            let exit =
-                self.context_value_exit(context_manager_type, kind, range, errors, Some(&context));
+            // Collect each protocol half's errors separately: when both halves fail (e.g. an
+            // async context manager in a sync `with`), both would otherwise surface as
+            // identical-header `bad-context-manager` errors on the same range. The enter
+            // half's error wins, since it is the first protocol failure in reading order.
+            let enter_errors = ErrorCollector::new(errors.module().clone(), ErrorStyle::Delayed);
+            let enter_type = self.context_value_enter(
+                context_manager_type,
+                kind,
+                range,
+                &enter_errors,
+                Some(&context),
+            );
+            let exit_errors = ErrorCollector::new(errors.module().clone(), ErrorStyle::Delayed);
+            let exit = self.context_value_exit(
+                context_manager_type,
+                kind,
+                range,
+                &exit_errors,
+                Some(&context),
+            );
+            if !enter_errors.is_empty() {
+                errors.extend(enter_errors);
+            } else {
+                errors.extend(exit_errors);
+            }
             let exit_type = self.union(exit.with_exception, exit.without_exception);
             self.check_type(
                 &exit_type,

pyrefly/lib/test/lsp/lsp_interaction/diagnostic.rs

@@ -928,19 +928,6 @@ fn test_error_documentation_links() {
                     "severity": 1,
                     "source": "Pyrefly"
                 },
-                {
-                    "code": "bad-context-manager",
-                    "codeDescription": {
-                        "href": "https://pyrefly.org/en/docs/error-kinds/#bad-context-manager"
-                    },
-                    "message": "Cannot use `A` as a context manager\n  Object of class `A` has no attribute `__exit__`",
-                    "range": {
-                        "end": {"character": 8, "line": 17},
-                        "start": {"character": 5, "line": 17}
-                    },
-                    "severity": 1,
-                    "source": "Pyrefly"
-                },
                 {
                     "code": "missing-attribute",
                     "codeDescription": {

pyrefly/lib/test/with.rs

@@ -571,15 +571,31 @@ testcase!(
     test_simple_with_error,
     r#"
 def test_sync() -> None:
-    with 42 as foo:  # E: Cannot use `Literal[42]` as a context manager\n  Object of class `int` has no attribute `__enter__` # E: has no attribute `__exit__`
+    with 42 as foo:  # E: Cannot use `Literal[42]` as a context manager\n  Object of class `int` has no attribute `__enter__`\n  Did you mean `__new__`?
         pass
 
 async def test_async() -> None:
-    async with "abc" as bar:  # E: has no attribute `__aenter__` # E: has no attribute `__aexit__`
+    async with "abc" as bar:  # E: Cannot use `Literal['abc']` as a context manager\n  Object of class `str` has no attribute `__aenter__`\n  Did you mean `__iter__`?
         pass
     "#,
 );
 
+// An async context manager used in a sync `with` breaks both protocol halves at
+// the same range; only one `bad-context-manager` error should be reported.
+testcase!(
+    test_async_context_manager_in_sync_with,
+    r#"
+from contextlib import asynccontextmanager
+
+@asynccontextmanager
+async def async_context():
+    yield
+
+with async_context():  # E: Cannot use `_AsyncGeneratorContextManager[None]` as a context manager\n  Object of class `_AsyncGeneratorContextManager` has no attribute `__enter__`\n  Did you mean `__aenter__`?
+    pass
+    "#,
+);
+
 testcase!(
     test_simple_with_wrong_enter_type,
     r#"