Doc: Clarify async generator expression behavior with nested async comprehensions

Author: tangyuan0821

.gitignore

@@ -178,3 +178,16 @@ CLAUDE.local.md
 #### main branch only stuff below this line, things to backport go above. ####
 # main branch only: ABI files are not checked/maintained.
 Doc/data/python*.abi
+validation_test.py
+test_nested_difference.py
+commit_message.txt
+demo_issue_138097.py
+PR_template.md
+check_format.py
+lint_check.py
+Doc/reference/expressions.rst
+check_our_changes.py
+clean_whitespace.py
+detailed_check.py
+check_fixed.py
+final_lint_check.py

Doc/reference/expressions.rst

@@ -310,10 +310,10 @@ the iterable expression in the leftmost :keyword:`!for` clause, it is called an
 execution of the coroutine function in which it appears.
 See also :pep:`530`.
 
-Note that this behavior extends to nested comprehensions: if a comprehension 
-contains an asynchronous comprehension in a nested scope, the outer comprehension
-implicitly becomes asynchronous. This also applies to generator expressions that
-contain asynchronous comprehensions.
+Note that this behavior extends to nested scopes: if a comprehension or generator
+expression contains asynchronous comprehensions (but not asynchronous generator
+expressions) in nested scopes, the outer comprehension or generator expression
+implicitly becomes asynchronous.
 
 .. versionadded:: 3.6
    Asynchronous comprehensions were introduced.
@@ -489,16 +489,21 @@ clauses or :keyword:`await` expressions it is called an
 expression returns a new asynchronous generator object,
 which is an asynchronous iterator (see :ref:`async-iterators`).
 
-Note that a generator expression becomes an asynchronous generator expression
-if it contains asynchronous comprehensions in nested scopes, such as an async 
-list comprehension within the generator expression. For example::
+Note that a generator expression also becomes an asynchronous generator expression
+if it contains asynchronous comprehensions (list, set, or dict comprehensions with
+:keyword:`!async for`) in nested scopes. For example::
 
     # This becomes an async generator expression
     ([a async for a in async_iterable] for x in [1])
 
-This behavior occurs because the inner async comprehension requires an 
-asynchronous context to execute, which causes the entire generator expression
-to become asynchronous.
+However, a generator expression that contains an asynchronous generator expression
+does *not* become asynchronous itself::
+
+    # This remains a regular generator expression
+    ((a async for a in async_iterable) for x in [1])
+
+This distinction exists because async comprehensions require immediate evaluation
+in an async context, while async generator expressions are lazily evaluated.
 
 .. versionadded:: 3.6
    Asynchronous generator expressions were introduced.