Handle negative, out of int range, and within int range cases

Author: Exanite

sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.VisitStmt.cs

@@ -45,21 +45,49 @@ private void VisitBinaryOperator(BinaryOperator binaryOperator)
         if (binaryOperator.IsShiftOp || binaryOperator.IsShiftAssignOp)
         {
             // RHS of shift operation in C# must be an int
-            if (binaryOperator.RHS.Type.Kind is CXType_Int || (binaryOperator.RHS.Type.Kind is CXType_Long && !_config.GenerateUnixTypes))
-            {
-                Visit(binaryOperator.RHS);
-            }
-            else if (binaryOperator.RHS is IntegerLiteral literal)
-            {
-                outputBuilder.Write(literal.Value);
-            }
-            else
+
+            // Negative shifts are undefined behavior in C/C++, but still needs to have a compilable output
+            var isNegated = binaryOperator.RHS is UnaryOperator { Opcode: CXUnaryOperator_Minus };
+            var sign = isNegated ? -1 : 1;
+
+            var rhs = isNegated ? ((UnaryOperator)binaryOperator.RHS).SubExpr : binaryOperator.RHS;
+            switch (rhs)
             {
-                outputBuilder.Write("(int)");
+                case IntegerLiteral literal:
+                {
+                    var value = sign * literal.Value;
+                    if (value is > int.MaxValue or < int.MinValue)
+                    {
+                        // Literal is in int32 range
+                        outputBuilder.Write("(int)(");
+                        outputBuilder.Write(sign * literal.Value);
+                        outputBuilder.Write(")");
+                    }
+                    else
+                    {
+                        // Literal is not in int32 range
+                        outputBuilder.Write(sign * literal.Value);
+                    }
 
-                outputBuilder.Write('(');
-                Visit(binaryOperator.RHS);
-                outputBuilder.Write(')');
+                    break;
+                }
+                // Already the correct type or implicitly castable
+                case { Type.Kind: CXType_Int or CXType_UShort or CXType_Short or CXType_Char_U or CXType_Char_S or CXType_UChar or CXType_SChar }:
+                case { Type.Kind: CXType_Long } when _config is { GenerateUnixTypes: false }:
+                case { Type.Kind: CXType_Char16 } when _config is { GenerateDisableRuntimeMarshalling: false }:
+                case { Type.Kind: CXType_WChar } when _config is { GenerateDisableRuntimeMarshalling: false, GenerateUnixTypes: false }:
+                {
+                    Visit(binaryOperator.RHS);
+                    break;
+                }
+                // Fallback
+                default:
+                {
+                    outputBuilder.Write("(int)(");
+                    Visit(binaryOperator.RHS);
+                    outputBuilder.Write(")");
+                    break;
+                }
             }
         }
         else

tests/ClangSharp.PInvokeGenerator.UnitTests/CTest.cs

@@ -292,9 +292,27 @@ public Task UnsignedIntBitshiftTest()
 const int ShiftSignedLong = 1 << SignedLong;
 const int ShiftUnsigned = 1 << Unsigned;
 
+const int Char = 1 << (signed char)1;
+const int UChar = 1 << (unsigned char)1;
+
 const int CInt = 1 << 1;
 const int CUint = 1 << 1U;
 
+const int Negative = 1 << -1;
+
+const int OutOfRangePos = 1 << 10000000000;
+const int OutOfRangeNeg = 1 << -10000000000;
+
+const int IntMax = 1 << 2147483647;
+const int IntMin = 1 << -2147483648;
+
+const int LongMax = 1 << 9223372036854775807;
+const int LongMin = 1 << -9223372036854775808;
+
+const int ULongMax = 1 << 18446744073709551615;
+
+const int Hexadecimal = 1 << 0x01;
+
 #define Left 1 << 1U
 #define Right 1 >> 1U
 
@@ -307,6 +325,11 @@ public Task UnsignedIntBitshiftTest()
 #define Complex ((((unsigned int)(0)) << 29U) | (((unsigned int)(1)) << 22U) | (((unsigned int)(0)) << 12U) | ((unsigned int)(0)))
 ";
 
+        // Non-ideal cases:
+        // UChar
+        // IntMin
+        // ULongMax
+        // Hexadecimal
         var expectedOutputContents = @"namespace ClangSharp.Test
 {
     public static partial class Methods
@@ -329,12 +352,45 @@ public static partial class Methods
         [NativeTypeName(""const int"")]
         public const int ShiftUnsigned = 1 << (int)(Unsigned);
 
+        [NativeTypeName(""const int"")]
+        public const int Char = 1 << (sbyte)(1);
+
+        [NativeTypeName(""const int"")]
+        public const int UChar = unchecked(1 << (byte)(1));
+
         [NativeTypeName(""const int"")]
         public const int CInt = 1 << 1;
 
         [NativeTypeName(""const int"")]
         public const int CUint = 1 << 1;
 
+        [NativeTypeName(""const int"")]
+        public const int Negative = 1 << -1;
+
+        [NativeTypeName(""const int"")]
+        public const int OutOfRangePos = unchecked(1 << (int)(10000000000));
+
+        [NativeTypeName(""const int"")]
+        public const int OutOfRangeNeg = unchecked(1 << (int)(-10000000000));
+
+        [NativeTypeName(""const int"")]
+        public const int IntMax = 1 << 2147483647;
+
+        [NativeTypeName(""const int"")]
+        public const int IntMin = unchecked(1 << -2147483648);
+
+        [NativeTypeName(""const int"")]
+        public const int LongMax = unchecked(1 << (int)(9223372036854775807));
+
+        [NativeTypeName(""const int"")]
+        public const int LongMin = unchecked(1 << (int)(-9223372036854775808));
+
+        [NativeTypeName(""const int"")]
+        public const int ULongMax = 1 << -1;
+
+        [NativeTypeName(""const int"")]
+        public const int Hexadecimal = 1 << 1;
+
         [NativeTypeName(""#define Left 1 << 1U"")]
         public const int Left = 1 << 1;