test negative shift folding via template simplifier

Move the regression test to testsimplifytemplate.cpp so it exercises the
reachable path through simplifyNumericCalculations instead of calling the
MathLib::value operators directly, which are not exported and broke the
Windows/test link.

Author: metsw24-max

test/testmathlib.cpp

@@ -64,7 +64,6 @@ class TestMathLib : public TestFixture {
         TEST_CASE(tan);
         TEST_CASE(abs);
         TEST_CASE(toString);
-        TEST_CASE(valueShift);
     }
 
     void isGreater() const {
@@ -1512,20 +1511,6 @@ class TestMathLib : public TestFixture {
         ASSERT_EQUALS("2.22507385851e-308", MathLib::toString(std::numeric_limits<double>::min()));
         ASSERT_EQUALS("1.79769313486e+308", MathLib::toString(std::numeric_limits<double>::max()));
     }
-
-    void valueShift() const {
-        // ordinary shifts
-        ASSERT_EQUALS("16", (MathLib::value("1") << MathLib::value("4")).str());
-        ASSERT_EQUALS("64", (MathLib::value("256") >> MathLib::value("2")).str());
-
-        // a large hex literal is not negative as a string but parses to a negative
-        // bigint; shifting it must not be performed (left shift of a negative value
-        // and shifting by a negative count are both undefined). the operand is
-        // returned unchanged, as already done for counts >= bigint_bits.
-        ASSERT_EQUALS("9223372036854775808U", (MathLib::value("0x8000000000000000") << MathLib::value("1")).str());
-        ASSERT_EQUALS("1", (MathLib::value("1") << MathLib::value("0x8000000000000000")).str());
-        ASSERT_EQUALS("1", (MathLib::value("1") >> MathLib::value("0x8000000000000000")).str());
-    }
 };
 
 REGISTER_TEST(TestMathLib)

test/testsimplifytemplate.cpp

@@ -320,6 +320,8 @@ class TestSimplifyTemplate : public TestFixture {
 
         TEST_CASE(templateArgPreserveType); // #13882 - type of template argument
 
+        TEST_CASE(template_shift_negative); // shift folding with a negative operand
+
         TEST_CASE(dumpTemplateArgFrom);
     }
 
@@ -6715,6 +6717,21 @@ class TestSimplifyTemplate : public TestFixture {
                       tok(code));
     }
 
+    void template_shift_negative() {
+        // a large hex literal is not negative as a string but parses to a negative
+        // bigint, so folding the shift in simplifyNumericCalculations would left-shift
+        // a negative value / shift by a negative count, both UB. the operand must be
+        // returned unchanged. parentheses are needed so the numeric folding is reached.
+        const char code[] = "template <long long> struct S { };\n"
+                            "S<(0x8000000000000000 << 1)> s1;\n"
+                            "S<(1 << 0x8000000000000000)> s2;\n"
+                            "S<(1 >> 0x8000000000000000)> s3;";
+        const char expected[] = "struct S<9223372036854775808U> ; struct S<1> ; "
+                                "S<9223372036854775808U> s1 ; S<1> s2 ; S<1> s3 ; "
+                                "struct S<9223372036854775808U> { } ; struct S<1> { } ;";
+        ASSERT_EQUALS(expected, tok(code));
+    }
+
     void dumpTemplateArgFrom() {
         const char code[] = "template<class T> void foo(T t) {}\n"
                             "foo<int>(23);";