diff --git a/Lib/test/test_type_params.py b/Lib/test/test_type_params.py
index 042cbcfd478af4..36e0a11a9fd451 100644
--- a/Lib/test/test_type_params.py
+++ b/Lib/test/test_type_params.py
@@ -436,11 +436,9 @@ class C[T]:
                 class Inner[U](make_base(T for _ in (1,)), make_base(T)):
                     pass
         """
-        C = run_code(code)["C"]
-        T, = C.__type_params__
-        base1, base2, _ = C.Inner.__bases__
-        self.assertEqual(list(base1.__arg__), [T])
-        self.assertEqual(base2.__arg__, "class")
+        with self.assertRaisesRegex(SyntaxError,
+                                    "Cannot use comprehension in annotation scope within class scope"):
+            run_code(code)
 
     def test_listcomp_in_nested_class(self):
         code = """
@@ -466,35 +464,40 @@ class C[T]:
                 class Inner[U](make_base([T for _ in (1,)]), make_base(T)):
                     pass
         """
-        C = run_code(code)["C"]
-        T, = C.__type_params__
-        base1, base2, _ = C.Inner.__bases__
-        self.assertEqual(base1.__arg__, [T])
-        self.assertEqual(base2.__arg__, "class")
+        with self.assertRaisesRegex(SyntaxError,
+                                    "Cannot use comprehension in annotation scope within class scope"):
+            run_code(code)
+
+    def test_gen_exp_in_generic_method(self):
+        code = """
+            class C[T]:
+                T = "class"
+                def meth[U](x: (T for _ in (1,)), y: T):
+                    pass
+        """
+        with self.assertRaisesRegex(SyntaxError,
+                                    "Cannot use comprehension in annotation scope within class scope"):
+            run_code(code)
 
     def test_lambda_in_generic_alias(self):
         code = """
             class C[T]:
                 T = "class"
-                type Alias1[T] = lambda: T
-                type Alias2 = lambda: T
-                type Alias3[T] = (T for _ in (1,))
-                type Alias4 = (T for _ in (1,))
-                type Alias5[T] = [T for _ in (1,)]
-                type Alias6 = [T for _ in (1,)]
+                {}
         """
-        C = run_code(code)["C"]
-        outer_T = C.__type_params__[0]
-        T1 = C.Alias1.__type_params__[0]
-        self.assertIs(C.Alias1.__value__(), T1)
-        # Shouldn't pick up the T from the class scope
-        self.assertIs(C.Alias2.__value__(), outer_T)
-        T3 = C.Alias3.__type_params__[0]
-        self.assertEqual(list(C.Alias3.__value__), [T3])
-        self.assertEqual(list(C.Alias4.__value__), [outer_T])
-        T5 = C.Alias5.__type_params__[0]
-        self.assertEqual(C.Alias5.__value__, [T5])
-        self.assertEqual(C.Alias6.__value__, [outer_T])
+        error_cases = [
+            "type Alias1[T] = lambda: T",
+            "type Alias2 = lambda: T",
+            "type Alias3[T] = (T for _ in (1,))",
+            "type Alias4 = (T for _ in (1,))",
+            "type Alias5[T] = [T for _ in (1,)]",
+            "type Alias6 = [T for _ in (1,)]",
+        ]
+        for case in error_cases:
+            with self.subTest(case=case):
+                with self.assertRaisesRegex(SyntaxError,
+                                            r"Cannot use [a-z]+ in annotation scope within class scope"):
+                    run_code(code.format(case))
 
 
 def make_base(arg):
diff --git a/Misc/NEWS.d/next/Core and Builtins/2023-09-09-12-49-46.gh-issue-109118.gx0X4h.rst b/Misc/NEWS.d/next/Core and Builtins/2023-09-09-12-49-46.gh-issue-109118.gx0X4h.rst
new file mode 100644
index 00000000000000..87069c85870410
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2023-09-09-12-49-46.gh-issue-109118.gx0X4h.rst	
@@ -0,0 +1,2 @@
+Disallow nested scopes (lambdas, generator expressions, and comprehensions)
+within PEP 695 annotation scopes that are nested within classes.
diff --git a/Python/symtable.c b/Python/symtable.c
index 7eef6f7231c035..65c18382c66dda 100644
--- a/Python/symtable.c
+++ b/Python/symtable.c
@@ -2011,6 +2011,17 @@ symtable_visit_expr(struct symtable *st, expr_ty e)
         VISIT(st, expr, e->v.UnaryOp.operand);
         break;
     case Lambda_kind: {
+        if (st->st_cur->ste_can_see_class_scope) {
+            // gh-109118
+            PyErr_Format(PyExc_SyntaxError,
+                         "Cannot use lambda in annotation scope within class scope");
+            PyErr_RangedSyntaxLocationObject(st->st_filename,
+                                              e->lineno,
+                                              e->col_offset + 1,
+                                              e->end_lineno,
+                                              e->end_col_offset + 1);
+            VISIT_QUIT(st, 0);
+        }
         if (e->v.Lambda.args->defaults)
             VISIT_SEQ(st, expr, e->v.Lambda.args->defaults);
         if (e->v.Lambda.args->kw_defaults)
@@ -2460,6 +2471,18 @@ symtable_handle_comprehension(struct symtable *st, expr_ty e,
                               identifier scope_name, asdl_comprehension_seq *generators,
                               expr_ty elt, expr_ty value)
 {
+    if (st->st_cur->ste_can_see_class_scope) {
+        // gh-109118
+        PyErr_Format(PyExc_SyntaxError,
+                     "Cannot use comprehension in annotation scope within class scope");
+        PyErr_RangedSyntaxLocationObject(st->st_filename,
+                                         e->lineno,
+                                         e->col_offset + 1,
+                                         e->end_lineno,
+                                         e->end_col_offset + 1);
+        VISIT_QUIT(st, 0);
+    }
+
     int is_generator = (e->kind == GeneratorExp_kind);
     comprehension_ty outermost = ((comprehension_ty)
                                     asdl_seq_GET(generators, 0));