@@ -5,12 +5,108 @@
 
 
 def test_compile_module():
+    class ModuleName(str):
+        pass
+
+    for module in (None, "", "package.module", ModuleName("package.module"), "\ud800"):
+        code = compile("value = 42", "<module-context>", "exec", module=module)
+        assert code.co_filename == "<module-context>"
+        namespace = {}
+        exec(code, namespace)
+        assert namespace["value"] == 42
+
+    for module in (1, False, b"package.module", [], {}, object()):
+        with assert_raises(TypeError) as caught:
+            compile("", "<module-context>", "exec", module=module)
+        assert "argument 'module' must be str or None" in str(caught.exception)
+
+    # module is keyword-only; _feature_version stays keyword-only too.
+    with assert_raises(TypeError):
+        compile("", "<module-context>", "exec", 0, False, -1, "package.module")
+
+    lexical_sources = [
+        "x = 1or 0",
+        r"'\z'",
+        r"'\400'",
+        r'f"{1:\z}"',
+        r'f"\{1}"',
+    ]
+    codegen_sources = [
+        "assert (1, 2)",
+        "1 is 1",
+        "def f():\n    try:\n        pass\n    finally:\n        return 1\n",
+    ]
+
+    # Default source compilation uses module for matching, while diagnostics retain
+    # the real source filename. Test both text and bytes compilation.
+    for source in lexical_sources + codegen_sources:
+        for input_source in (source, source.encode()):
+            with warnings.catch_warnings(record=True) as caught:
+                warnings.simplefilter("error", SyntaxWarning)
+                warnings.filterwarnings(
+                    "always", category=SyntaxWarning, module=r"^package\.module$"
+                )
+                compile(
+                    input_source, "<module-context>", "exec", module="package.module"
+                )
+            assert len(caught) == 1, (source, caught)
+            assert caught[0].filename == "<module-context>"
+            assert caught[0].category is SyntaxWarning
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", SyntaxWarning)
+                warnings.filterwarnings(
+                    "error", category=SyntaxWarning, module=r"^package\.module$"
+                )
+                with assert_raises(SyntaxError):
+                    compile(
+                        input_source,
+                        "<module-context>",
+                        "exec",
+                        module="package.module",
+                    )
+
+    # Compiling a pre-existing AST must use the module too.
+    for source in codegen_sources:
+        tree = ast.parse(source)
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("error", SyntaxWarning)
+            warnings.filterwarnings(
+                "always", category=SyntaxWarning, module=r"^package\.module$"
+            )
+            compile(tree, "<module-context>", "exec", module="package.module")
+        assert len(caught) == 1, (source, caught)
+        assert caught[0].filename == "<module-context>"
+
+    # A following compile, with omitted or None module, must not inherit the override.
+    for kwargs in ({}, {"module": None}):
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("error", SyntaxWarning)
+            warnings.filterwarnings(
+                "always", category=SyntaxWarning, module=r"^<module-context>$"
+            )
+            compile("1 is 1", "<module-context>", "exec", **kwargs)
+        assert len(caught) == 1
+
+    # Failed parses use the fallback string scanner, which must retain the module.
+    for source in (r"b'\z' )", r'f"{1:\z}" )'):
+        with warnings.catch_warnings(record=True) as caught:
+            warnings.simplefilter("error", SyntaxWarning)
+            warnings.filterwarnings(
+                "always", category=SyntaxWarning, module=r"^package\.module$"
+            )
+            with assert_raises(SyntaxError):
+                compile(source, "<module-context>", "exec", module="package.module")
+        assert len(caught) == 1, (source, caught)
+        assert caught[0].filename == "<module-context>"
+
     # AST conversion must use the same fallible, source-located warning boundary.
     # TYPE_COMMENTS validates through the AST parser before compiling the source;
     # the later compiler must not filter or emit the same escape a second time.
     for flags in (
         ast.PyCF_ONLY_AST,
         ast.PyCF_TYPE_COMMENTS,
+        ast.PyCF_ONLY_AST | ast.PyCF_TYPE_COMMENTS,
+        ast.PyCF_ONLY_AST | ast.PyCF_OPTIMIZED_AST,
     ):
         source = '\nπ = f"{1:\\z}"\n'
         for kwargs, expected_module in (
@@ -34,6 +130,27 @@ def match(self, module):
             assert modules == [expected_module], (flags, kwargs, modules)
             assert len(caught) == 1, (flags, kwargs, caught)
             assert (caught[0].filename, caught[0].lineno) == ("<module-context>", 2)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", SyntaxWarning)
+            warnings.filterwarnings(
+                "error", category=SyntaxWarning, module=r"^package\.module$"
+            )
+            with assert_raises(SyntaxError) as caught:
+                compile(
+                    source, "<module-context>", "exec", flags, module="package.module"
+                )
+        error = caught.exception
+        assert error.filename == "<module-context>"
+        assert (error.lineno, error.offset, error.end_lineno, error.end_offset) == (
+            2,
+            10,
+            2,
+            12,
+        )
+        assert error.text == 'π = f"{1:\\z}"\n'
+        assert "Such sequences will not work in the future" not in error.msg
+
         # Warning handlers may raise arbitrary exceptions, which must survive intact.
         failure = RuntimeError("warning handler failed")
 
@@ -78,7 +195,27 @@ def showwarning(message, category, filename, lineno, *args, **kwargs):
             )
         assert modules == ["package.outer", "package.inner", "package.outer"], modules
         assert locations == [("<outer>", 1), ("<inner>", 1), ("<outer>", 2)], locations
-    for flags in (ast.PyCF_ONLY_AST,):
+
+    # These warnings already came from AST conversion. Retain them instead of
+    # replacing that path with a broader scanner before every AST parse.
+    for source in ('''rf"{1:{'\\z'}}"''', '''f"{1:{t'\\z'}}"'''):
+        for flags in (
+            ast.PyCF_ONLY_AST,
+            ast.PyCF_TYPE_COMMENTS,
+            ast.PyCF_ONLY_AST | ast.PyCF_TYPE_COMMENTS,
+        ):
+            with warnings.catch_warnings(record=True) as caught:
+                warnings.simplefilter("error", SyntaxWarning)
+                warnings.filterwarnings(
+                    "always", category=SyntaxWarning, module=r"^package\.module$"
+                )
+                compile(
+                    source, "<module-context>", "exec", flags, module="package.module"
+                )
+            assert len(caught) == 1, (source, flags, caught)
+            assert (caught[0].filename, caught[0].lineno) == ("<module-context>", 1)
+
+    for flags in (ast.PyCF_ONLY_AST, ast.PyCF_ONLY_AST | ast.PyCF_TYPE_COMMENTS):
         with warnings.catch_warnings(record=True) as caught:
             warnings.simplefilter("always", SyntaxWarning)
             with assert_raises(SyntaxError):
@@ -110,6 +247,38 @@ def showwarning(*args, **kwargs):
             )
     assert caught.exception.lineno == 2
     assert "\\q" in caught.exception.msg
+
+    # Raw literal text is not an invalid escape. Nested nonraw expressions still
+    # retain the diagnostics previously emitted during AST conversion.
+    for flags in (
+        ast.PyCF_ONLY_AST,
+        ast.PyCF_TYPE_COMMENTS,
+        ast.PyCF_ONLY_AST | ast.PyCF_TYPE_COMMENTS,
+    ):
+        for source in (
+            r'rf"{1:\z}"',
+            r'rf"{1:{2:\z}}"',
+            r'tr"{1:{2:\z}}"',
+            "f\"{1:{r'\\z'}}\"",
+        ):
+            with warnings.catch_warnings(record=True) as caught:
+                warnings.simplefilter("error", SyntaxWarning)
+                compile(
+                    source, "<module-context>", "exec", flags, module="package.module"
+                )
+            assert not caught, (source, flags, caught)
+        for source in ("rf\"{f'{2:\\z}'}\"", "rf\"{1:{'\\z'}}\""):
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", SyntaxWarning)
+                with assert_raises(SyntaxError):
+                    compile(
+                        source,
+                        "<module-context>",
+                        "exec",
+                        flags,
+                        module="package.module",
+                    )
+
     # Func-type parsing trims its source before converting the parsed nodes.
     # Already-detected escapes must still point into the original source.
     for prefix in ("", "\n\n"):