[flang] Operands of SIGN() need not have same kind

[klausler]

Summary

The standard requires that the operands of the intrinsic function
SIGN() must have the same type (INTEGER or REAL), but they are not
required to have the same kind.

[PeteSteinfeld]

All builds and tests correctly and looks good.

flang/lib/Evaluate/intrinsics.cpp

// NULL() is a special case handled in Probe() below
             {"radix", AnyInt, Rank::scalar}},
         DefaultInt, Rank::scalar, IntrinsicClass::transformationalFunction},
     {"set_exponent", {{"x", SameReal}, {"i", AnyInt}}, SameReal},
     {"shape", {{"source", AnyData, Rank::anyOrAssumedRank}, SizeDefaultKIND},
         KINDInt, Rank::vector, IntrinsicClass::inquiryFunction},
     {"shifta", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"shiftl", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
     {"shiftr", {{"i", SameInt}, {"shift", AnyInt}}, SameInt},
-    {"sign", {{"a", SameIntOrReal}, {"b", SameIntOrReal}}, SameIntOrReal},
+    {"sign", {{"a", SameInt}, {"b", AnyInt}}, SameInt},
+    {"sign", {{"a", SameReal}, {"b", AnyReal}}, SameReal},
     {"sin", {{"x", SameFloating}}, SameFloating},
     {"sind", {{"x", SameFloating}}, SameFloating},
     {"sinh", {{"x", SameFloating}}, SameFloating},
     {"size",
         {{"array", AnyData, Rank::anyOrAssumedRank},
             OptionalDIM, // unless array is assumed-size
             SizeDefaultKIND},
         KINDInt, Rank::scalar, IntrinsicClass::inquiryFunction},

flang/test/Evaluate/folding02.f90

module m
   ! to intrinsic functions but not to test the stability between different libraries.
   ! The eps should just be low enough to give confidence that intrinsic
   ! functions are mapped to runtime functions implementing the same math
   ! function.
   ! Compared values were selected to be around 1 +/- 0.5 so that eps is meaningful.
   ! Expected values come from libpgmath-precise for Real(4) and Real(8) and
   ! were computed on X86_64.
 
-  logical, parameter :: test_sign_i4 = sign(1_4,2_4) == 1_4 .and. sign(1_4,-3_4) == -1_4
-  logical, parameter :: test_sign_i8 = sign(1_8,2_8) == 1_8 .and. sign(1_8,-3_8) == -1_8
+  logical, parameter :: test_sign_i4 = sign(1_4,2) == 1_4 .and. sign(1_4,-3_8) == -1_4
+  logical, parameter :: test_sign_i8 = sign(1_8,2) == 1_8 .and. sign(1_8,-3_8) == -1_8
 
 ! Real scalar intrinsic function tests
 #define TEST_FLOATING(name, result, expected, t, k) \
   t(kind = k), parameter ::res_##name##_##t##k = result; \
   t(kind = k), parameter ::exp_##name##_##t##k = expected; \
   logical, parameter ::test_##name##_##t##k = abs(res_##name##_##t##k - exp_##name##_##t##k).LE.(eps##k)
 
 #define TEST_R2(name, result, expected) TEST_FLOATING(name, result, expected, real, 2)
! REAL(4) tests.
   TEST_R4(exp, exp(0.1_4), 1.1051709651947021484375_4)
   TEST_R4(gamma, gamma(0.9_4), 1.06862866878509521484375_4)
   TEST_R4(hypot, hypot(1.1_4, 0.1_4), 1.10453617572784423828125_4)
   TEST_R4(log, log(3._4), 1.098612308502197265625_4)
   TEST_R4(log10, log10(10.5_4), 1.02118933200836181640625_4)
   TEST_R4(log_gamma, log_gamma(3.5_4), 1.20097362995147705078125_4)
   TEST_R4(mod, mod(-8.1_4, 5._4), (-3.1000003814697265625_4))
   TEST_R4(real, real(z'3f800000'), 1._4)
-  logical, parameter :: test_sign_r4 = sign(1._4,2._4) == 1._4 .and. sign(1._4,-2._4) == -1._4
+  logical, parameter :: test_sign_r4 = sign(1._4,2._8) == 1._4 .and. sign(1._4,-2._4) == -1._4
   TEST_R4(sin, sin(1.6_4), 0.99957358837127685546875_4)
   TEST_R4(sinh, sinh(0.9_4), 1.0265166759490966796875_4)
   TEST_R4(sqrt, sqrt(1.1_4), 1.0488088130950927734375_4)
   TEST_R4(tan, tan(0.8_4), 1.0296385288238525390625_4)
   TEST_R4(tanh, tanh(3._4), 0.995054781436920166015625_4)
 
 ! REAL(8) tests.
 
TEST_R8(log, log(3._8), &
     1.0986122886681097821082175869378261268138885498046875_8)
   TEST_R8(log10, log10(10.5_8), &
     1.0211892990699380501240511875948868691921234130859375_8)
   TEST_R8(log_gamma, log_gamma(3.5_8), &
     1.200973602347074287166606154642067849636077880859375_8)
   TEST_R8(mod, mod(-8.1_8, 5._8), &
     (-3.0999999999999996447286321199499070644378662109375_8))
   TEST_R8(real, real(z'3ff0000000000000',8), 1._8)
-  logical, parameter :: test_sign_r8 = sign(1._8,2._8) == 1._8 .and. sign(1._8,-2._8) == -1._8
+  logical, parameter :: test_sign_r8 = sign(1._8,2._8) == 1._8 .and. sign(1._8,-2._4) == -1._8
   TEST_R8(sin, sin(1.6_8), &
     0.99957360304150510987852840116829611361026763916015625_8)
   TEST_R8(sinh, sinh(0.9_8), &
     1.0265167257081753149350333842448890209197998046875_8)
   TEST_R8(sqrt, sqrt(1.1_8), &
     1.048808848170151630796453900984488427639007568359375_8)
   TEST_R8(tan, tan(0.8_8), &
     1.0296385570503641115891468871268443763256072998046875_8)