Merge pull request #811 from Sergio0694/dev/shader-linking-fixes2

Rework linking analyzer, remove generator heuristic, change D2D compile options

Author: Sergio0694

src/ComputeSharp.D2D1.SourceGenerators/D2DPixelShaderDescriptorGenerator.HlslBytecode.cs

@@ -1,4 +1,3 @@
-using System;
 using ComputeSharp.SourceGeneration.Extensions;
 using Microsoft.CodeAnalysis;
 
@@ -76,83 +75,12 @@ public static D2D1ShaderProfile GetEffectiveShaderProfile(D2D1ShaderProfile? sha
         /// Gets the effective compile options to use.
         /// </summary>
         /// <param name="compileOptions">The requested compile options.</param>
-        /// <param name="isLinkingSupported">Whether the input shader supports linking.</param>
         /// <returns>The effective compile options.</returns>
-        public static D2D1CompileOptions GetEffectiveCompileOptions(D2D1CompileOptions? compileOptions, bool isLinkingSupported)
+        public static D2D1CompileOptions GetEffectiveCompileOptions(D2D1CompileOptions? compileOptions)
         {
             // If an explicit set of compile options is provided, use that directly. Otherwise, use the default
             // options plus the option to enable linking only if the shader can potentially support it.
-            return compileOptions ?? (D2D1CompileOptions.Default | (isLinkingSupported ? D2D1CompileOptions.EnableLinking : 0));
-        }
-
-        /// <summary>
-        /// Extracts the metadata definition for the current shader.
-        /// </summary>
-        /// <param name="compilation">The input <see cref="Compilation"/> object currently in use.</param>
-        /// <param name="structDeclarationSymbol">The input <see cref="INamedTypeSymbol"/> instance to process.</param>
-        /// <param name="inputCount">The number of inputs for the shader.</param>
-        /// <returns>Whether the shader only has simple inputs.</returns>
-        public static bool IsSimpleInputShader(
-            Compilation compilation,
-            INamedTypeSymbol structDeclarationSymbol,
-            int inputCount)
-        {
-            return IsSimpleInputShader(
-                structDeclarationSymbol,
-                compilation.GetTypeByMetadataName("ComputeSharp.D2D1.D2DInputSimpleAttribute")!,
-                inputCount);
-        }
-
-        /// <summary>
-        /// Extracts the metadata definition for the current shader.
-        /// </summary>
-        /// <param name="structDeclarationSymbol">The input <see cref="INamedTypeSymbol"/> instance to process.</param>
-        /// <param name="d2DInputSimpleSymbolAttributeSymbol">The symbol for the <c>[D2DInputSimple]</c> attribute.</param>
-        /// <param name="inputCount">The number of inputs for the shader.</param>
-        /// <returns>Whether the shader only has simple inputs.</returns>
-        public static bool IsSimpleInputShader(
-            INamedTypeSymbol structDeclarationSymbol,
-            INamedTypeSymbol d2DInputSimpleSymbolAttributeSymbol,
-            int inputCount)
-        {
-            // We cannot trust the input count to be valid at this point (it may be invalid and
-            // with diagnostic already emitted for it). So first, just clamp it in the right range.
-            inputCount = Math.Max(0, Math.Min(8, inputCount));
-
-            // If there are no inputs, the shader is as if only had simple inputs
-            if (inputCount == 0)
-            {
-                return true;
-            }
-
-            // Build a map of all simple inputs (unmarked inputs default to being complex).
-            // We can never have more than 8 inputs, and if there are it means the shader is
-            // not valid. Just ignore them, and the generator will emit a separate diagnostic.
-            Span<bool> simpleInputsMap = stackalloc bool[8];
-
-            // We first start with all inputs marked as complex (ie. not simple)
-            simpleInputsMap.Clear();
-
-            foreach (AttributeData attributeData in structDeclarationSymbol.GetAttributes())
-            {
-                // Only retrieve indices of simple inputs that are in range. If an input is out of
-                // range, the diagnostic for it will already be emitted by a previous generator step.
-                if (SymbolEqualityComparer.Default.Equals(attributeData.AttributeClass, d2DInputSimpleSymbolAttributeSymbol) &&
-                    attributeData.ConstructorArguments is [{ Value: >= 0 and < 8 and int index }])
-                {
-                    simpleInputsMap[index] = true;
-                }
-            }
-
-            bool isSimpleInputShader = true;
-
-            // Validate all inputs in our range (filtered by the allowed one)
-            foreach (bool isSimpleInput in simpleInputsMap[..inputCount])
-            {
-                isSimpleInputShader &= isSimpleInput;
-            }
-
-            return isSimpleInputShader;
+            return compileOptions ?? D2D1CompileOptions.Default;
         }
     }
 }

src/ComputeSharp.D2D1.SourceGenerators/D2DPixelShaderDescriptorGenerator.cs

@@ -128,11 +128,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                     token.ThrowIfCancellationRequested();
 
                     // Get the shader profile and linking info for the HLSL bytecode properties
-                    bool isLinkingSupported = HlslBytecode.IsSimpleInputShader(context.SemanticModel.Compilation, typeSymbol, inputCount);
                     D2D1ShaderProfile? requestedShaderProfile = HlslBytecode.GetRequestedShaderProfile(typeSymbol);
                     D2D1CompileOptions? requestedCompileOptions = HlslBytecode.GetRequestedCompileOptions(typeSymbol);
                     D2D1ShaderProfile effectiveShaderProfile = HlslBytecode.GetEffectiveShaderProfile(requestedShaderProfile, out bool isCompilationEnabled);
-                    D2D1CompileOptions effectiveCompileOptions = HlslBytecode.GetEffectiveCompileOptions(requestedCompileOptions, isLinkingSupported);
+                    D2D1CompileOptions effectiveCompileOptions = HlslBytecode.GetEffectiveCompileOptions(requestedCompileOptions);
 
                     token.ThrowIfCancellationRequested();
 

src/ComputeSharp.D2D1.SourceGenerators/Diagnostics/Analyzers/InvalidD2D1CompileOptionsEnableLinkingOnShaderTypeAnalyzer.cs

@@ -0,0 +1,120 @@
+using System;
+using System.Collections.Immutable;
+using ComputeSharp.SourceGeneration.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using static ComputeSharp.SourceGeneration.Diagnostics.DiagnosticDescriptors;
+
+namespace ComputeSharp.D2D1.SourceGenerators;
+
+/// <summary>
+/// A diagnostic analyzer that generates an error whenever [D2DPixelOptions] is used on a shader type to incorrectly request trivial sampling.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class InvalidD2D1PixelOptionsTrivialSamplingOnShaderTypeAnalyzer : DiagnosticAnalyzer
+{
+    /// <inheritdoc/>
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = [InvalidD2D1PixelOptionsTrivialSamplingOnShaderType];
+
+    /// <inheritdoc/>
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+        context.EnableConcurrentExecution();
+
+        context.RegisterCompilationStartAction(static context =>
+        {
+            // Get the [D2DPixelOptions], [D2DInputCount] and [D2DInputSimple] symbols
+            if (context.Compilation.GetTypeByMetadataName("ComputeSharp.D2D1.D2DPixelOptionsAttribute") is not { } d2DPixelOptionsAttributeSymbol ||
+                context.Compilation.GetTypeByMetadataName("ComputeSharp.D2D1.D2DInputCountAttribute") is not { } d2DInputCountAttributeSymbol ||
+                context.Compilation.GetTypeByMetadataName("ComputeSharp.D2D1.D2DInputSimpleAttribute") is not { } d2DInputSimpleAttributeSymbol)
+            {
+                return;
+            }
+
+            context.RegisterSymbolAction(context =>
+            {
+                // Only struct types are possible targets
+                if (context.Symbol is not INamedTypeSymbol { TypeKind: TypeKind.Struct } typeSymbol)
+                {
+                    return;
+                }
+
+                // If the type is not using [D2DPixelOptions] with D2D1PixelOptions.TrivialSampling, there's nothing to do
+                if (!typeSymbol.TryGetAttributeWithType(d2DPixelOptionsAttributeSymbol, out AttributeData? pixelOptionsAttribute) ||
+                    !((D2D1PixelOptions)pixelOptionsAttribute.ConstructorArguments[0].Value!).HasFlag(D2D1PixelOptions.TrivialSampling))
+                {
+                    return;
+                }
+
+                // Make sure we have the [D2DInputCount] (if not present, the shader is invalid anyway) and with a valid value
+                if (!typeSymbol.TryGetAttributeWithType(d2DInputCountAttributeSymbol, out AttributeData? inputCountAttribute) ||
+                    inputCountAttribute.ConstructorArguments is not [{ Value: >= 0 and < 8 and int inputCount }])
+                {
+                    return;
+                }
+
+                // Emit a diagnostic if the compile options are not valid for the shader type
+                if (!IsSimpleInputShader(typeSymbol, d2DInputSimpleAttributeSymbol, inputCount))
+                {
+                    context.ReportDiagnostic(Diagnostic.Create(
+                        InvalidD2D1PixelOptionsTrivialSamplingOnShaderType,
+                        pixelOptionsAttribute.GetLocation(),
+                        typeSymbol));
+                }
+            }, SymbolKind.NamedType);
+        });
+    }
+
+    /// <summary>
+    /// Checks whether a given shader only has simple inputs.
+    /// </summary>
+    /// <param name="structDeclarationSymbol">The input <see cref="INamedTypeSymbol"/> instance to process.</param>
+    /// <param name="d2DInputSimpleSymbolAttributeSymbol">The symbol for the <c>[D2DInputSimple]</c> attribute.</param>
+    /// <param name="inputCount">The number of inputs for the shader.</param>
+    /// <returns>Whether the shader only has simple inputs.</returns>
+    private static bool IsSimpleInputShader(
+        INamedTypeSymbol structDeclarationSymbol,
+        INamedTypeSymbol d2DInputSimpleSymbolAttributeSymbol,
+        int inputCount)
+    {
+        // We cannot trust the input count to be valid at this point (it may be invalid and
+        // with diagnostic already emitted for it). So first, just clamp it in the right range.
+        inputCount = Math.Max(0, Math.Min(8, inputCount));
+
+        // If there are no inputs, the shader is as if only had simple inputs
+        if (inputCount == 0)
+        {
+            return true;
+        }
+
+        // Build a map of all simple inputs (unmarked inputs default to being complex).
+        // We can never have more than 8 inputs, and if there are it means the shader is
+        // not valid. Just ignore them, and the generator will emit a separate diagnostic.
+        Span<bool> simpleInputsMap = stackalloc bool[8];
+
+        // We first start with all inputs marked as complex (ie. not simple)
+        simpleInputsMap.Clear();
+
+        foreach (AttributeData attributeData in structDeclarationSymbol.GetAttributes())
+        {
+            // Only retrieve indices of simple inputs that are in range. If an input is out of
+            // range, the diagnostic for it will already be emitted by a previous generator step.
+            if (SymbolEqualityComparer.Default.Equals(attributeData.AttributeClass, d2DInputSimpleSymbolAttributeSymbol) &&
+                attributeData.ConstructorArguments is [{ Value: >= 0 and < 8 and int index }])
+            {
+                simpleInputsMap[index] = true;
+            }
+        }
+
+        bool isSimpleInputShader = true;
+
+        // Validate all inputs in our range (filtered by the allowed one)
+        foreach (bool isSimpleInput in simpleInputsMap[..inputCount])
+        {
+            isSimpleInputShader &= isSimpleInput;
+        }
+
+        return isSimpleInputShader;
+    }
+}

src/ComputeSharp.D2D1.SourceGenerators/Diagnostics/Analyzers/InvalidD2D1PixelOptionsTrivialSamplingOnShaderTypeAnalyzer.cs

@@ -1024,19 +1024,19 @@ partial class DiagnosticDescriptors
         helpLinkUri: "https://github.com/Sergio0694/ComputeSharp");
 
     /// <summary>
-    /// Gets a <see cref="DiagnosticDescriptor"/> for an invalid use of <c>[D2DCompileOptions]</c> requesting to enable linking.
+    /// Gets a <see cref="DiagnosticDescriptor"/> for an invalid use of <c>[D2DPixelOptions]</c> indicating trivial sampling.
     /// <para>
-    /// Format: <c>"The D2D1 shader of type {0} cannot use D2D1CompileOptions.EnableLinking in its [D2DCompileOptions] attribute, as it doesn't support linking (only D2D1 shaders with no complex inputs can use this option)"</c>.
+    /// Format: <c>"The D2D1 shader of type {0} shouldn't use D2D1PixelOptions.TrivialSampling in its [D2DPixelOptions] attribute, as it has one or more complex inputs (either mark the inputs as simple, or remove the trivial sampling option)"</c>.
     /// </para>
     /// </summary>
-    public static readonly DiagnosticDescriptor InvalidD2D1CompileOptionsEnableLinkingOnShaderType = new(
+    public static readonly DiagnosticDescriptor InvalidD2D1PixelOptionsTrivialSamplingOnShaderType = new(
         id: "CMPSD2D0069",
-        title: "Invalid [D2DResourceTextureIndex] use",
-        messageFormat: """The D2D1 shader of type {0} cannot use D2D1CompileOptions.EnableLinking in its [D2DCompileOptions] attribute, as it doesn't support linking (only D2D1 shaders with no complex inputs can use this option)""",
+        title: "Invalid [D2DPixelOptions] use",
+        messageFormat: """The D2D1 shader of type {0} shouldn't use D2D1PixelOptions.TrivialSampling in its [D2DPixelOptions] attribute, as it has one or more complex inputs (either mark the inputs as simple, or remove the trivial sampling option)""",
         category: "ComputeSharp.D2D1.Shaders",
         defaultSeverity: DiagnosticSeverity.Warning,
         isEnabledByDefault: true,
-        description: "A D2D1 shader cannot use D2D1CompileOptions.EnableLinking in its [D2DCompileOptions] attribute if it doesn't support linking (only D2D1 shaders with no complex inputs can use this option).",
+        description: "A D2D1 shader shouldn't use D2D1PixelOptions.TrivialSampling in its [D2DPixelOptions] attribute if it has one or more complex inputs (because trivial sampling shaders can only sample pixels at the same scene coordinate as the output pixel, a shader using this option should only have simple inputs).",
         helpLinkUri: "https://github.com/Sergio0694/ComputeSharp");
 
     /// <summary>