Tweak tests

Author: Eclips4

Lib/test/test_ast/test_ast.py

@@ -3153,14 +3153,6 @@ def test_folding_binop(self):
             ):
                 self.assert_ast(result_code, non_optimized_target, optimized_target)
 
-        # Tuple folding is currently disabled in the AST optimizer
-        # Multiplication of constant tuples must be folded
-        # code = "(1,) * 3"
-        # non_optimized_target = self.wrap_expr(self.create_binop("*", ast.Tuple(elts=[ast.Constant(value=1)]), ast.Constant(value=3)))
-        # optimized_target = self.wrap_expr(ast.Constant(eval(code)))
-
-        # self.assert_ast(code, non_optimized_target, optimized_target)
-
     def test_folding_unaryop(self):
         code = "%s1"
         operators = self.unaryop.keys()
@@ -3180,39 +3172,6 @@ def create_unaryop(operand):
             ):
                 self.assert_ast(result_code, non_optimized_target, optimized_target)
 
-    @unittest.skip("Tuple folding is currently disabled in the AST optimizer")
-    def test_folding_not(self):
-        code = "not (1 %s (1,))"
-        operators = {
-            "in": ast.In(),
-            "is": ast.Is(),
-        }
-        opt_operators = {
-            "is": ast.IsNot(),
-            "in": ast.NotIn(),
-        }
-
-        def create_notop(operand):
-            return ast.UnaryOp(op=ast.Not(), operand=ast.Compare(
-                left=ast.Constant(value=1),
-                ops=[operators[operand]],
-                comparators=[ast.Tuple(elts=[ast.Constant(value=1)])]
-            ))
-
-        for op in operators.keys():
-            result_code = code % op
-            non_optimized_target = self.wrap_expr(create_notop(op))
-            optimized_target = self.wrap_expr(
-                ast.Compare(left=ast.Constant(1), ops=[opt_operators[op]], comparators=[ast.Constant(value=(1,))])
-            )
-
-            with self.subTest(
-                result_code=result_code,
-                non_optimized_target=non_optimized_target,
-                optimized_target=optimized_target
-            ):
-                self.assert_ast(result_code, non_optimized_target, optimized_target)
-
     def test_folding_format(self):
         code = "'%s' % (a,)"
 
@@ -3232,15 +3191,6 @@ def test_folding_format(self):
 
         self.assert_ast(code, non_optimized_target, optimized_target)
 
-    @unittest.skip("Tuple folding is currently disabled in the AST optimizer")
-    def test_folding_tuple(self):
-        code = "(1,)"
-
-        non_optimized_target = self.wrap_expr(ast.Tuple(elts=[ast.Constant(1)]))
-        optimized_target = self.wrap_expr(ast.Constant(value=(1,)))
-
-        self.assert_ast(code, non_optimized_target, optimized_target)
-
     def test_folding_comparator(self):
         code = "1 %s %s1%s"
         operators = [("in", ast.In()), ("not in", ast.NotIn())]
@@ -3281,15 +3231,15 @@ def test_folding_iter(self):
 
             self.assert_ast(code % (left, right), non_optimized_target, optimized_target)
 
-    @unittest.skip("Tuple folding is currently disabled in the AST optimizer")
     def test_folding_subscript(self):
-        code = "(1,)[0]"
+        code = "'abcd'[0]"
 
         non_optimized_target = self.wrap_expr(
-            ast.Subscript(value=ast.Tuple(elts=[ast.Constant(value=1)]), slice=ast.Constant(value=0))
+            ast.Subscript(value=ast.Constant(value='abcd'), slice=ast.Constant(value=0))
+        )
+        optimized_target = self.wrap_expr(
+            ast.JoinedStr(values=[ast.Constant(value='a')])
         )
-        optimized_target = self.wrap_expr(ast.Constant(value=1))
-
         self.assert_ast(code, non_optimized_target, optimized_target)
 
     def test_folding_type_param_in_function_def(self):

Lib/test/test_compile.py

@@ -793,19 +793,6 @@ def check_same_constant(const):
         self.check_constant(f1, Ellipsis)
         self.assertEqual(repr(f1()), repr(Ellipsis))
 
-        # Merge constants in tuple or frozenset
-        f1, f2 = lambda: "not a name", lambda: ("not a name",)
-        f3 = lambda x: x in {("not a name",)}
-        # TODO: I'm not sure if this is right..
-        self.assertIs(f1.__code__.co_consts[0],
-                      f2.__code__.co_consts[0])
-        self.assertIs(f1.__code__.co_consts[0],
-                      f2.__code__.co_consts[1][0])
-        self.assertIs(f1.__code__.co_consts[0],
-                      f3.__code__.co_consts[0])
-        self.assertIs(f1.__code__.co_consts[0],
-                      f3.__code__.co_consts[1][0])
-
         # {0} is converted to a constant frozenset({0}) by the peephole
         # optimizer
         f1, f2 = lambda x: x in {0}, lambda x: x in {0}

Lib/test/test_opcache.py

@@ -1508,26 +1508,14 @@ def to_bool_str():
     @cpython_only
     @requires_specialization_ft
     def test_unpack_sequence(self):
-        # Tuple folding is currently disabled in the AST optimizer
-        # def unpack_sequence_two_tuple():
-        #     for _ in range(100):
-        #         a, b = 1, 2
-        #         self.assertEqual(a, 1)
-        #         self.assertEqual(b, 2)
-
-        # unpack_sequence_two_tuple()
-        # self.assert_specialized(unpack_sequence_two_tuple,
-        #                         "UNPACK_SEQUENCE_TWO_TUPLE")
-        # self.assert_no_opcode(unpack_sequence_two_tuple, "UNPACK_SEQUENCE")
-
-        # def unpack_sequence_tuple():
-        #     for _ in range(100):
-        #         a, = 1,
-        #         self.assertEqual(a, 1)
-
-        # unpack_sequence_tuple()
-        # self.assert_specialized(unpack_sequence_tuple, "UNPACK_SEQUENCE_TUPLE")
-        # self.assert_no_opcode(unpack_sequence_tuple, "UNPACK_SEQUENCE")
+        def unpack_sequence_tuple():
+            for _ in range(100):
+                a, b, c, d = 1, 2, 3, 4
+                self.assertEqual((a, b, c, d), (1, 2, 3, 4))
+
+        unpack_sequence_tuple()
+        self.assert_specialized(unpack_sequence_tuple, "UNPACK_SEQUENCE_TUPLE")
+        self.assert_no_opcode(unpack_sequence_tuple, "UNPACK_SEQUENCE")
 
         def unpack_sequence_list():
             for _ in range(100):

Python/ast_opt.c

@@ -555,20 +555,6 @@ make_const_tuple(asdl_expr_seq *elts)
     return newval;
 }
 
-static int
-fold_tuple(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
-{
-    return 1;
-    // Disable tuple folding for now
-    // PyObject *newval;
-
-    // if (node->v.Tuple.ctx != Load)
-    //     return 1;
-
-    // newval = make_const_tuple(node->v.Tuple.elts);
-    // return make_const(node, newval, arena);
-}
-
 static int
 fold_subscr(expr_ty node, PyArena *arena, _PyASTOptimizeState *state)
 {
@@ -839,7 +825,6 @@ astfold_expr(expr_ty node_, PyArena *ctx_, _PyASTOptimizeState *state)
         break;
     case Tuple_kind:
         CALL_SEQ(astfold_expr, expr, node_->v.Tuple.elts);
-        CALL(fold_tuple, expr_ty, node_);
         break;
     case Name_kind:
         if (node_->v.Name.ctx == Load &&