Add Reference Type Warnings

Samples/AdjustableSharedMemory/Program.cs

@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                    ILGPU Samples
-//                           Copyright (c) 2021 ILGPU Project
+//                        Copyright (c) 2021-2024 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: Program.cs
@@ -31,7 +31,7 @@ interface ISharedAllocationSize
         struct SharedArray32 : ISharedAllocationSize
         {
             /// <summary>
-            /// Returns a 
+            /// Returns a
             /// </summary>
             public int ArraySize => 32;
         }
@@ -49,7 +49,7 @@ struct SharedArray64 : ISharedAllocationSize
         /// <param name="sharedArray">Implicit shared-memory parameter that is handled by the runtime.</param>
         static void SharedMemoryKernel<TSharedAllocationSize>(
             ArrayView<int> outputView)   // A view to a chunk of memory (1D in this case)
-            where TSharedAllocationSize : struct, ISharedAllocationSize
+            where TSharedAllocationSize : unmanaged, ISharedAllocationSize
         {
             // Compute the global 1D index for accessing the data view
             var globalIndex = Grid.GlobalIndex.X;
@@ -66,7 +66,7 @@ static void SharedMemoryKernel<TSharedAllocationSize>(
         }
 
         static void ExecuteSample<TSharedAllocationSize>(Context context)
-            where TSharedAllocationSize : struct, ISharedAllocationSize
+            where TSharedAllocationSize : unmanaged, ISharedAllocationSize
         {
             // For each available device...
             foreach (var device in context)

Samples/GenericKernel/Program.cs

@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                    ILGPU Samples
-//                           Copyright (c) 2021 ILGPU Project
+//                        Copyright (c) 2021-2024 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: Program.cs
@@ -72,7 +72,7 @@ static void Kernel<TKernelFunction, T>(
             ArrayView<T> data,
             int value,
             TKernelFunction function)
-            where TKernelFunction : struct, IKernelFunction<T>
+            where TKernelFunction : unmanaged, IKernelFunction<T>
             where T : unmanaged
         {
             // Invoke the custom "lambda function"

Samples/ILGPU.Samples.sln

@@ -135,6 +135,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ILGPU.Analyzers", "..\Src\I
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "InterleaveFields", "InterleaveFields\InterleaveFields.csproj", "{1E6D0BC6-CFA1-4F52-9EB9-CAA62DD2F33A}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ILGPU.Analyzers", "ILGPU.Analyzers", "{6D111E09-49A1-492E-B4CE-E18CE27B56A8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ManagedTypeAnalyzer", "ManagedTypeAnalyzer\ManagedTypeAnalyzer.csproj", "{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -381,6 +385,10 @@ Global
 		{1E6D0BC6-CFA1-4F52-9EB9-CAA62DD2F33A}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1E6D0BC6-CFA1-4F52-9EB9-CAA62DD2F33A}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1E6D0BC6-CFA1-4F52-9EB9-CAA62DD2F33A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -449,6 +457,7 @@ Global
 		{70B69CE3-24A9-463C-B14C-E2934988BBEE} = {25BA2234-5778-40BC-9386-9CE87AB87D1F}
 		{1C5E9E39-3C14-4B52-8D97-04555D5F6331} = {03FCC663-945D-4982-90D8-B14BE52D8FCD}
 		{1E6D0BC6-CFA1-4F52-9EB9-CAA62DD2F33A} = {C1D99632-ED4A-4B08-A14D-4C8DB375934F}
+		{6176F0D0-4A34-42DB-BDFB-2D8ED80868C3} = {6D111E09-49A1-492E-B4CE-E18CE27B56A8}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {30E502BD-3826-417F-888F-1CE19CF5C6DA}

Samples/ManagedTypeAnalyzer/ManagedTypeAnalyzer.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>$(LibrarySamplesTargetFrameworks)</TargetFrameworks>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <RootNamespace>ManagedTypeAnalyzer</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Src\ILGPU\ILGPU.csproj"/>
+    <ProjectReference Include="..\..\Src\ILGPU.Analyzers\ILGPU.Analyzers.csproj"
+                      OutputItemType="Analyzer"
+                      ReferenceOutputAssembly="false"/>
+  </ItemGroup>
+
+</Project>

Samples/ManagedTypeAnalyzer/Program.cs

@@ -0,0 +1,88 @@
+// ---------------------------------------------------------------------------------------
+//                                    ILGPU Samples
+//                           Copyright (c) 2024 ILGPU Project
+//                                    www.ilgpu.net
+//
+// File: Program.cs
+//
+// This file is part of ILGPU and is distributed under the University of Illinois Open
+// Source License. See LICENSE.txt for details.
+// ---------------------------------------------------------------------------------------
+
+using ILGPU;
+using ILGPU.Runtime;
+using System.Diagnostics.CodeAnalysis;
+
+namespace ManagedTypeAnalyzer;
+
+// Disable warnings for build
+[SuppressMessage("Usage", "ILA003:Managed type in kernel")]
+[SuppressMessage("Usage", "ILA004:Array of managed types in kernel")]
+class Program
+{
+    class RefType
+    {
+        public int Hello => 42;
+    }
+
+    struct ValueType
+    {
+        public int Hello;
+
+        public ValueType()
+        {
+            Hello = 42;
+        }
+    }
+
+    static int AnotherFunction()
+    {
+        return new RefType().Hello;
+    }
+
+    static void Kernel(Index1D index, ArrayView<int> input, ArrayView<int> output)
+    {
+        // This is disallowed, since MyRefType is a reference type
+        var refType = new RefType();
+        output[index] = input[index] + refType.Hello;
+
+        // Allocating arrays of unmanaged types is fine
+        ValueType[] array =
+        {
+            new ValueType()
+        };
+
+        int[] ints =
+        {
+            0, 1, 2
+        };
+
+        // But arrays of reference types are still disallowed
+        RefType[] other =
+        {
+            new RefType(),
+        };
+
+        // Any functions that may be called are also analyzed
+        int result = AnotherFunction();
+    }
+
+    static void Main(string[] args)
+    {
+        using var context = Context.CreateDefault();
+        var device = context.GetPreferredDevice(false);
+        using var accelerator = device.CreateAccelerator(context);
+
+        using var input = accelerator.Allocate1D<int>(1024);
+        using var output = accelerator.Allocate1D<int>(1024);
+
+        var kernel =
+            accelerator
+                .LoadAutoGroupedStreamKernel<Index1D, ArrayView<int>, ArrayView<int>>(
+                    Kernel);
+
+        kernel(input.IntExtent, input.View, output.View);
+
+        accelerator.Synchronize();
+    }
+}

Samples/StaticAbstractInterfaceMembers/Program.cs

@@ -1,6 +1,6 @@
 // ---------------------------------------------------------------------------------------
 //                                    ILGPU Samples
-//                           Copyright (c) 2023 ILGPU Project
+//                        Copyright (c) 2023-2024 ILGPU Project
 //                                    www.ilgpu.net
 //
 // File: Program.cs
@@ -66,13 +66,13 @@ public interface ICalculatorOperation<T>
         {
             T Calculate(T left, T right);
         }
-        
+
         // Interface must be implemented by a 'struct'.
         public struct AdditionOp : ICalculatorOperation<int>
         {
             public int Calculate(int left, int right) => left + right;
         }
-        
+
         // Interface must be implemented by a 'struct'.
         public struct MultiplyOp : ICalculatorOperation<float>
         {
@@ -84,7 +84,7 @@ public static void CalculatorKernel<T, TOp>(
             ArrayView1D<T, Stride1D.Dense> input,
             ArrayView1D<T, Stride1D.Dense> output)
             where T : unmanaged
-            where TOp : struct, ICalculatorOperation<T>
+            where TOp : unmanaged, ICalculatorOperation<T>
         {
             // Creates a new instance of the struct, and calls the method.
             output[index] = default(TOp).Calculate(input[index], input[index]);
@@ -98,7 +98,7 @@ public static void UsingAbstractFunction<T, TOp>(Accelerator accelerator)
             where TOp : ICalculatorOperation<T>
 #else
             where T : unmanaged
-            where TOp : struct, ICalculatorOperation<T>
+            where TOp : unmanaged, ICalculatorOperation<T>
 #endif
         {
             var values =

Src/ILGPU.Analyzers.Tests/Generic/DiagnosticAnalyzerVerifier.cs

@@ -0,0 +1,68 @@
+// ---------------------------------------------------------------------------------------
+//                                        ILGPU
+//                           Copyright (c) 2024 ILGPU Project
+//                                    www.ilgpu.net
+//
+// File: DiagnosticAnalyzerVerifier.cs
+//
+// This file is part of ILGPU and is distributed under the University of Illinois Open
+// Source License. See LICENSE.txt for details.
+// ---------------------------------------------------------------------------------------
+
+using System;
+using System.Collections.Immutable;
+using System.IO;
+using System.Threading.Tasks;
+using ILGPU.CodeGeneration;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using VerifyTests;
+using VerifyXunit;
+
+namespace ILGPU.Analyzers.Tests.Generic;
+
+/// <summary>
+/// Verifies the output of running <c>TDiagnosticAnalyzer</c> on C# source.
+/// </summary>
+/// <typeparam name="TDiagnosticAnalyzer">The diagnostic analyzer to run.</typeparam>
+public static class DiagnosticAnalyzerVerifier<TDiagnosticAnalyzer>
+    where TDiagnosticAnalyzer : DiagnosticAnalyzer, new()
+{
+    /// <summary>
+    /// Verifies the output of running <c>TDiagnosticAnalyzer</c> on <c>source</c> using
+    /// snapshots.
+    /// </summary>
+    /// <param name="source">The source to run the analyzer on.</param>
+    /// <param name="configure">
+    /// Optional action to configure verification settings.
+    /// </param>
+    public static async Task Verify(string source,
+        Action<VerifySettings> configure = null)
+    {
+        var ilgpuAssemblies =
+            new[]
+            {
+                typeof(InterleaveFieldsAttribute).Assembly,
+                typeof(TDiagnosticAnalyzer).Assembly
+            };
+
+        var compilation =
+            SourceCompiler.CreateCompilationWithAssemblies("Tests", source,
+                ilgpuAssemblies);
+
+        var array = ImmutableArray.Create<DiagnosticAnalyzer>(new TDiagnosticAnalyzer());
+        var options = new AnalyzerOptions(ImmutableArray<AdditionalText>.Empty);
+        var analyzerCompilation =
+            new CompilationWithAnalyzers(compilation, array, options);
+
+        var diagnostics = await analyzerCompilation.GetAnalyzerDiagnosticsAsync();
+
+        var settings = new VerifySettings();
+        settings.UseDirectory(Path.Combine("..", "Snapshots"));
+
+        if (configure is not null)
+            configure(settings);
+
+        await Verifier.Verify(diagnostics, settings);
+    }
+}

Src/ILGPU.Analyzers.Tests/Generic/IncrementalGeneratorVerifier.cs

@@ -12,46 +12,40 @@
 using ILGPU.CodeGeneration;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using System;
 using System.IO;
-using System.Linq;
 using System.Threading.Tasks;
 using VerifyTests;
 using VerifyXunit;
 
-namespace ILGPU.Analyzers.Tests
+namespace ILGPU.Analyzers.Tests.Generic
 {
+    /// <summary>
+    /// Verifies the output source from the source generator <c>TIncrementalGenerator</c>
+    /// using snapshots.
+    /// </summary>
+    /// <typeparam name="TIncrementalGenerator">
+    /// The generator to run on source text.
+    /// </typeparam>
     public static class IncrementalGeneratorVerifier<TIncrementalGenerator>
         where TIncrementalGenerator : IIncrementalGenerator, new()
     {
+        /// <summary>
+        /// Verifies the C# source generated by <c>TIncrementalGenerator</c>.
+        /// </summary>
+        /// <param name="source">The source text to run the generator on.</param>
+        /// <returns>A task that runs the generator and verifies the output.</returns>
         public static Task Verify(string source)
         {
-            // Parse syntax tree.
-            var syntaxTree = CSharpSyntaxTree.ParseText(source);
-
-            // Add system references.
-            var trustedAssembliesPaths =
-                (string)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES");
-            var systemReferences =
-                trustedAssembliesPaths
-                .Split(Path.PathSeparator)
-                .Select(x => MetadataReference.CreateFromFile(x))
-                .ToArray();
-
-            var ilgpuReferences =
+            var ilgpuAssemblies =
                 new[]
                 {
-                    typeof(InterleaveFieldsAttribute),
-                    typeof(TIncrementalGenerator)
-                }
-                .Select(x => MetadataReference.CreateFromFile(x.Assembly.Location))
-                .ToArray();
+                    typeof(InterleaveFieldsAttribute).Assembly,
+                    typeof(TIncrementalGenerator).Assembly
+                };
 
-            // Create a roslyn compilation for the syntax tree.
-            var compilation = CSharpCompilation.Create(
-                "Tests",
-                new[] { syntaxTree },
-                references: systemReferences.Concat(ilgpuReferences));
+            var compilation =
+                SourceCompiler.CreateCompilationWithAssemblies("Tests", source,
+                    ilgpuAssemblies);
 
             // Create an instance of the incremental source generator.
             var generator = new TIncrementalGenerator();
@@ -65,4 +59,4 @@ public static Task Verify(string source)
             return Verifier.Verify(driver, settings);
         }
     }
-}
+}