Expand IL test coverage and improve extractor file handling

Added multiple new methods to SimpleClass.cs to test a wide range of IL instructions, including floating point operations, array manipulation, pointer operations, field access, conversions, boxing/unboxing, exception handling, type checks, bitwise and comparison operations, and switch statements. Updated TestAssembly.csproj to allow unsafe blocks for pointer tests. Refactored ILExtractor.cs to dispose assemblies before copying files and improved archive path handling for source archiving.

Author: gfs

binary/extractor/cil/Semmle.Extraction.CSharp.IL/ILExtractor.cs

@@ -19,35 +19,38 @@ public ILExtractor(TrapWriter trapWriter) {
   public void Extract(string dllPath) {
     Console.WriteLine($"Extracting {dllPath}...");
 
-    var assembly = AssemblyDefinition.ReadAssembly(dllPath);
-
-    // Write file info
-    var fileId = trap.GetId();
-    trap.WriteTuple("files", fileId, dllPath);
-
-    // Write assembly info
-    var assemblyId = trap.GetId();
-    trap.WriteTuple("assemblies", assemblyId, fileId, assembly.Name.Name,
-                    assembly.Name.Version.ToString());
-
-    foreach (var module in assembly.Modules) {
-      foreach (var type in module.Types) {
-        // Skip compiler-generated types for now
-        if (type.Name.Contains("<") || type.Name.StartsWith("<"))
-          continue;
-
-        ExtractType(type);
+    // Read and process the assembly in a scoped block so it's disposed before file copy
+    using (var assembly = AssemblyDefinition.ReadAssembly(dllPath)) {
+      // Write file info
+      var fileId = trap.GetId();
+      trap.WriteTuple("files", fileId, dllPath);
+
+      // Write assembly info
+      var assemblyId = trap.GetId();
+      trap.WriteTuple("assemblies", assemblyId, fileId, assembly.Name.Name,
+                      assembly.Name.Version.ToString());
+
+      foreach (var module in assembly.Modules) {
+        foreach (var type in module.Types) {
+          // Skip compiler-generated types for now
+          if (type.Name.Contains("<") || type.Name.StartsWith("<"))
+            continue;
+
+          ExtractType(type);
+        }
       }
     }
 
+    // Copy to source archive (after assembly is closed)
     var cilSourceArchiveDir = Environment.GetEnvironmentVariable(
         "CODEQL_EXTRACTOR_CIL_SOURCE_ARCHIVE_DIR");
     if (string.IsNullOrEmpty(cilSourceArchiveDir)) {
       throw new InvalidOperationException(
           "Environment variable CODEQL_EXTRACTOR_CIL_SOURCE_ARCHIVE_DIR is not set.");
     }
-    var dllArchivePath =
-        Path.Combine(cilSourceArchiveDir, dllPath.Replace(":", "_"));
+    // Convert absolute path to relative for archive: strip leading / or drive letter
+    var relativeDllPath = dllPath.TrimStart('/').Replace(":", "_");
+    var dllArchivePath = Path.Combine(cilSourceArchiveDir, relativeDllPath);
     // Ensure directory exists
     var archiveDir = Path.GetDirectoryName(dllArchivePath);
     if (!Directory.Exists(archiveDir)) {

binary/test-inputs/TestAssembly/SimpleClass.cs

@@ -32,5 +32,154 @@ public void LoopExample()
                 Console.WriteLine(i);
             }
         }
+
+        // Test float and double constants (ldc.r4, ldc.r8)
+        public float GetPi()
+        {
+            return 3.14159f;
+        }
+
+        public double GetE()
+        {
+            return 2.71828;
+        }
+
+        public double FloatArithmetic(float a, double b)
+        {
+            float localFloat = 1.5f;
+            double localDouble = 2.5;
+            return (a + localFloat) * (b + localDouble);
+        }
+
+        // Test more local variable operations
+        public int LocalVariableTest()
+        {
+            int a = 1;
+            int b = 2;
+            int c = 3;
+            int d = 4;
+            int e = 5;  // Forces use of ldloc.s/stloc.s for indices >= 4
+            return a + b + c + d + e;
+        }
+
+        // Test array operations (ldelem, stelem)
+        public int ArrayTest()
+        {
+            int[] arr = new int[5];
+            arr[0] = 10;
+            arr[1] = 20;
+            arr[2] = 30;
+            return arr[0] + arr[1] + arr[2];
+        }
+
+        public float[] FloatArrayTest()
+        {
+            float[] arr = new float[3];
+            arr[0] = 1.1f;
+            arr[1] = 2.2f;
+            arr[2] = 3.3f;
+            return arr;
+        }
+
+        // Test indirect load/store (ldind, stind)
+        public unsafe void PointerTest()
+        {
+            int value = 42;
+            int* ptr = &value;
+            *ptr = 100;
+            int result = *ptr;
+        }
+
+        // Test field operations (ldfld, stfld, ldsfld, stsfld)
+        private int _instanceField = 0;
+        private static int _staticField = 0;
+
+        public void FieldTest()
+        {
+            _instanceField = 10;
+            int x = _instanceField;
+            _staticField = 20;
+            int y = _staticField;
+        }
+
+        // Test conversions (conv.*)
+        public void ConversionTest()
+        {
+            int i = 42;
+            long l = (long)i;       // conv.i8
+            float f = (float)i;     // conv.r4
+            double d = (double)i;   // conv.r8
+            byte b = (byte)i;       // conv.u1
+            short s = (short)i;     // conv.i2
+        }
+
+        // Test boxing/unboxing
+        public void BoxingTest()
+        {
+            int value = 42;
+            object boxed = value;       // box
+            int unboxed = (int)boxed;   // unbox.any
+        }
+
+        // Test exception handling
+        public void ExceptionTest()
+        {
+            try
+            {
+                throw new InvalidOperationException("test");
+            }
+            catch (InvalidOperationException ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+            finally
+            {
+                Console.WriteLine("finally");
+            }
+        }
+
+        // Test type checking (isinst, castclass)
+        public void TypeCheckTest(object obj)
+        {
+            if (obj is string str)      // isinst
+            {
+                Console.WriteLine(str);
+            }
+            
+            var cast = (SimpleClass)obj;  // castclass
+        }
+
+        // Test bitwise operations
+        public int BitwiseTest(int a, int b)
+        {
+            int andResult = a & b;
+            int orResult = a | b;
+            int xorResult = a ^ b;
+            int notResult = ~a;
+            int shlResult = a << 2;
+            int shrResult = a >> 2;
+            return andResult + orResult + xorResult + notResult + shlResult + shrResult;
+        }
+
+        // Test comparison operations (ceq, clt, cgt)
+        public bool ComparisonTest(int a, int b)
+        {
+            bool eq = a == b;
+            bool lt = a < b;
+            bool gt = a > b;
+            return eq || lt || gt;
+        }
+
+        // Test switch statement
+        public string SwitchTest(int value)
+        {
+            switch (value)
+            {
+                case 0: return "zero";
+                case 1: return "one";
+                case 2: return "two";
+                default: return "other";
+            }
+        }
     }
 }

binary/test-inputs/TestAssembly/TestAssembly.csproj

@@ -5,6 +5,7 @@
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
     <OutputType>Library</OutputType>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
 </Project>