Cast integer literals to target type

I ran into a case where the C++ compiler wants the suffix (or a cast): std::max(0, x) does not compile if x is of 64 bit integer type. On my machine 32 bit is the correct threshold and I think this is fairly standard. However, AFAIK it is technically platform dependent, so should we emit a cast to the target type instead?

Update: According to the standard long long (ll suffix) guarantees at least 64 bit. However, we might run into similar issues with smaller types. So I updated the MR such that integer literals are always cast to the target type. Starting with C99, an integer literal is automatically assigned a 64 bit type, if the number does not fit into 32 bit. This means that we currently do not support integer literals >32 bit prior to C99. A quarter century later, I think this is OK.

src/pystencils/types/types.py

@@ -483,8 +483,7 @@ class PsIntegerType(PsScalarType, ABC):
         if not isinstance(value, np_dtype):
             raise PsTypeError(f"Given value {value} is not of required type {np_dtype}")
         unsigned_suffix = "" if self.signed else "u"
-        #   TODO: cast literal to correct type?
-        return str(value) + unsigned_suffix
+        return f"(({self._c_type_without_const()}) {value}{unsigned_suffix})"
 
     def create_constant(self, value: Any) -> Any:
         np_type = self.NUMPY_TYPES[self._width]
@@ -499,9 +498,12 @@ class PsIntegerType(PsScalarType, ABC):
 
         raise PsTypeError(f"Could not interpret {value} as {repr(self)}")
 
-    def c_string(self) -> str:
+    def _c_type_without_const(self) -> str:
         prefix = "" if self._signed else "u"
-        return f"{self._const_string()}{prefix}int{self._width}_t"
+        return f"{prefix}int{self._width}_t"
+
+    def c_string(self) -> str:
+        return f"{self._const_string()}{self._c_type_without_const()}"
 
     def __repr__(self) -> str:
         return f"PsIntegerType( width={self.width}, signed={self.signed}, const={self.const} )"