gh-103492: Clarify SyntaxWarning with literal comparison

Lib/test/test_codeop.py

@@ -277,7 +277,7 @@ def test_filename(self):
     def test_warning(self):
         # Test that the warning is only returned once.
         with warnings_helper.check_warnings(
-                ('"is" with a literal', SyntaxWarning),
+                ('"is" with str literal', SyntaxWarning),
                 ("invalid escape sequence", SyntaxWarning),
                 ) as w:
             compile_command(r"'\e' is 0")

Lib/test/test_grammar.py

@@ -237,7 +237,7 @@ def check(test, error=False):
             check(f"{num}spam", error=True)
 
             with warnings.catch_warnings():
-                warnings.filterwarnings('ignore', '"is" with a literal',
+                warnings.filterwarnings('ignore', '"is" with int literal',
                                         SyntaxWarning)
                 with self.assertWarnsRegex(SyntaxWarning,
                             r'invalid \w+ literal'):
@@ -1467,21 +1467,30 @@ def test_comparison(self):
         if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in x is x is not x: pass
 
     def test_comparison_is_literal(self):
-        def check(test, msg='"is" with a literal'):
+        def check(test, msg):
             self.check_syntax_warning(test, msg)
 
-        check('x is 1')
-        check('x is "thing"')
-        check('1 is x')
-        check('x is y is 1')
-        check('x is not 1', '"is not" with a literal')
+        check('x is 1', '"is" with int literal')
+        check('x is "thing"', '"is" with str literal')
+        check('1 is x', '"is" with int literal')
+        check('x is y is 1', '"is" with int literal')
+        check('x is not 1', '"is not" with int literal')
+        check('x is not (1, 2)', '"is not" with tuple literal')
+        check('(1, 2) is not x', '"is not" with tuple literal')
+
+        check('None is 1', '"is" with int literal')
+        check('1 is None', '"is" with int literal')
 
         with warnings.catch_warnings():
             warnings.simplefilter('error', SyntaxWarning)
             compile('x is None', '<testcase>', 'exec')
             compile('x is False', '<testcase>', 'exec')
             compile('x is True', '<testcase>', 'exec')
             compile('x is ...', '<testcase>', 'exec')
+            compile('None is x', '<testcase>', 'exec')
+            compile('False is x', '<testcase>', 'exec')
+            compile('True is x', '<testcase>', 'exec')
+            compile('... is x', '<testcase>', 'exec')
 
     def test_warn_missed_comma(self):
         def check(test):

Misc/NEWS.d/next/Core and Builtins/2023-04-13-00-58-55.gh-issue-103492.P4k0Ay.rst

@@ -0,0 +1 @@
+Clarify :exc:`SyntaxWarning` with literal ``is`` comparison by specifying which literal is problematic, since comparisons using ``is`` with e.g. None and bool literals are idiomatic.

Python/compile.c

@@ -2280,13 +2280,17 @@ check_compare(struct compiler *c, expr_ty e)
     n = asdl_seq_LEN(e->v.Compare.ops);
     for (i = 0; i < n; i++) {
         cmpop_ty op = (cmpop_ty)asdl_seq_GET(e->v.Compare.ops, i);
-        bool right = check_is_arg((expr_ty)asdl_seq_GET(e->v.Compare.comparators, i));
+        expr_ty right_expr = (expr_ty)asdl_seq_GET(e->v.Compare.comparators, i);
+        bool right = check_is_arg(right_expr);
         if (op == Is || op == IsNot) {
             if (!right || !left) {
                 const char *msg = (op == Is)
-                        ? "\"is\" with a literal. Did you mean \"==\"?"
-                        : "\"is not\" with a literal. Did you mean \"!=\"?";
-                return compiler_warn(c, LOC(e), msg);
+                        ? "\"is\" with %.200s literal. Did you mean \"==\"?"
+                        : "\"is not\" with %.200s literal. Did you mean \"!=\"?";
+                expr_ty literal = !left ? e->v.Compare.left : right_expr;
+                return compiler_warn(
+                    c, LOC(e), msg, Py_TYPE(literal->v.Constant.value)->tp_name
+                );
             }
         }
         left = right;