diff --git a/ets2panda/checker/ets/narrowingConverter.h b/ets2panda/checker/ets/narrowingConverter.h
index 8c9a6562cbc5a062ae9349e74773ddd4c257e8d9..111d84dcd600dba0f805c1111d875d34d3fa8d36 100644
--- a/ets2panda/checker/ets/narrowingConverter.h
+++ b/ets2panda/checker/ets/narrowingConverter.h
@@ -104,38 +104,29 @@ private:
     }
 
     template <typename SType>
-    int CalculateIntValue(Type *target, SType value)
+    int CalculateIntValue(SType value)
     {
-        switch (ETSChecker::ETSChecker::ETSType(target)) {
-            case TypeFlag::BYTE:
-            case TypeFlag::CHAR:
-            case TypeFlag::SHORT: {
-                if (std::isinf(value)) {
-                    return std::numeric_limits<int32_t>::max();
-                }
-                if (std::signbit(std::isinf(value))) {
-                    return std::numeric_limits<int32_t>::min();
-                }
-                if (std::isnan(value)) {
-                    return 0;
-                }
-                return static_cast<int32_t>(value);
-            }
-            default: {
-                return 0;
+        if (std::isinf(value)) {
+            if (std::signbit(value)) {
+                return std::numeric_limits<int32_t>::min();
             }
+            return std::numeric_limits<int32_t>::max();
         }
+        if (std::isnan(value)) {
+            return 0;
+        }
+        return static_cast<int32_t>(value);
     }
 
     template <typename From, typename To>
     To CastFloatingPointToIntOrLong(From value)
     {
         if (std::isinf(value)) {
+            if (std::signbit(value)) {
+                return std::numeric_limits<To>::min();
+            }
             return std::numeric_limits<To>::max();
         }
-        if (std::signbit(std::isinf(value))) {
-            return std::numeric_limits<To>::min();
-        }
         ASSERT(std::is_floating_point_v<From>);
         ASSERT(std::is_integral_v<To>);
         To minInt = std::numeric_limits<To>::min();
@@ -162,7 +153,7 @@ private:
             case TypeFlag::BYTE:
             case TypeFlag::CHAR:
             case TypeFlag::SHORT: {
-                return CalculateIntValue<SType>(target, value);
+                return CalculateIntValue<SType>(value);
             }
             case TypeFlag::INT:
             case TypeFlag::LONG: {
diff --git a/ets2panda/test/runtime/ets/conversionFromInfinity.ets b/ets2panda/test/runtime/ets/conversionFromInfinity.ets
index 812df0fe9e9b1d94183042ad02a60e76755c5a1b..f87376cb6afd8bd0bf1afaba49f73cab6ca0188f 100644
--- a/ets2panda/test/runtime/ets/conversionFromInfinity.ets
+++ b/ets2panda/test/runtime/ets/conversionFromInfinity.ets
@@ -44,42 +44,54 @@ assert(b3 == -1)
 let l1 = Infinity as long
 let l2: double = Infinity
 let l3 = l2 as long
+let l4 = -Infinity as long
 
 assert(l1 == 9223372036854775807)
 assert(l3 == 9223372036854775807)
+assert(l4 == -9223372036854775808)
 
 let i1 = Infinity as int
 let i2: double = Infinity
 let i3 = i2 as int
+let i4 = -Infinity as int
 
 assert(i1 == 2147483647)
 assert(i3 == 2147483647)
+assert(i4 == -2147483648)
 
 let s1 = Infinity as short
 let s2: double = Infinity
 let s3 = s2 as short
+let s4 = -Infinity as short
 
 assert(s1 == -1)
 assert(s3 == -1)
+assert(s4 == 0)
 
 let c1 = Infinity as char
 let c2: double = Infinity
 let c3 = c2 as char
+let c4 = -Infinity as char
 
 assert(c1 == 65535)
 assert(c3 == 65535)
+assert(c4 == 0)
 
 let f1 = Infinity as float
 let f2: double = Infinity
 let f3 = f2 as float
+let f4 = -Infinity as float
 
 assert(f1 == Infinity)
 assert(f3 == Infinity)
+assert(f4 == -Infinity)
 
 let d1 = Infinity as double
 let d2: double = Infinity
 let d3 = d2 as double
+let d4 = -Infinity as double
 
 assert(d1 == Infinity)
 assert(d3 == Infinity)
+assert(d4 == -Infinity)
 }