compiler now ignores constant statements

The compile ignores constant statements and emit a SyntaxWarning warning.

Don't emit the warning for string statement because triple quoted string is a
common syntax for multiline comments.

Don't emit the warning on ellipis neither: 'def f(): ...' is a legit syntax for
abstract functions.

Changes:

* test_ast: ignore SyntaxWarning when compiling test statements. Modify
  test_load_const() to use assignment expressions rather than constant
  expression.
* test_code: add more kinds of constant statements, ignore SyntaxWarning when
  testing that the compiler removes constant statements.
* test_grammar: ignore SyntaxWarning on the statement "1"

Lib/test/test_ast.py

@@ -3,6 +3,7 @@ import dis
 import os
 import sys
 import unittest
+import warnings
 import weakref
 
 from test import support
@@ -239,8 +240,10 @@ class AST_Tests(unittest.TestCase):
                     ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
                     self.assertEqual(to_tuple(ast_tree), o)
                     self._assertTrueorder(ast_tree, (0, 0))
-                with self.subTest(action="compiling", input=i):
-                    compile(ast_tree, "?", kind)
+                with warnings.catch_warnings():
+                    warnings.filterwarnings('ignore', category=SyntaxWarning)
+                    with self.subTest(action="compiling", input=i, kind=kind):
+                        compile(ast_tree, "?", kind)
 
     def test_slice(self):
         slc = ast.parse("x[::]").body[0].value.slice
@@ -1020,27 +1023,23 @@ class ConstantTests(unittest.TestCase):
                   b'bytes',
                   (1, 2, 3)]
 
-        code = '\n'.join(map(repr, consts))
-        code += '\n...'
-
-        code_consts = [const for const in consts
-                       if (not isinstance(const, (str, int, float, complex))
-                           or isinstance(const, bool))]
-        code_consts.append(Ellipsis)
-        # the compiler adds a final "LOAD_CONST None"
-        code_consts.append(None)
+        code = '\n'.join(['x={!r}'.format(const) for const in consts])
+        code += '\nx = ...'
+        consts.extend((Ellipsis, None))
 
         tree = ast.parse(code)
-        self.assertEqual(self.get_load_const(tree), code_consts)
+        self.assertEqual(self.get_load_const(tree),
+                         consts)
 
         # Replace expression nodes with constants
-        for expr_node, const in zip(tree.body, consts):
-            assert isinstance(expr_node, ast.Expr)
+        for assign, const in zip(tree.body, consts):
+            assert isinstance(assign, ast.Assign), ast.dump(assign)
             new_node = ast.Constant(value=const)
-            ast.copy_location(new_node, expr_node.value)
-            expr_node.value = new_node
+            ast.copy_location(new_node, assign.value)
+            assign.value = new_node
 
-        self.assertEqual(self.get_load_const(tree), code_consts)
+        self.assertEqual(self.get_load_const(tree),
+                         consts)
 
     def test_literal_eval(self):
         tree = ast.parse("1 + 2")