Merge pull request #400 from Sergio0694/dev/raw-multiline-toggle

Only emit raw multiline string literals when possible

src/ComputeSharp.D2D1.SourceGenerators/ID2D1ShaderGenerator.CreateBuildHlslSourceMethod.Syntax.cs

@@ -1,5 +1,6 @@
 using ComputeSharp.D2D1.__Internals;
 using ComputeSharp.SourceGeneration.Helpers;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -19,9 +20,16 @@ partial class BuildHlslSource
  /// </summary>
  /// <param name="hlslSource">The input HLSL source.</param>
  /// <param name="hierarchyDepth">The depth of the hierarchy for this type (used to calculate the right indentation).</param>
+ /// <param name="useRawMultiLineStringLiteralExpression">Whether to use a raw multiline string literal expression</param>
  /// <returns>The resulting <see cref="MethodDeclarationSyntax"/> instance for the <c>BuildHlslSource</c> method.</returns>
- public static MethodDeclarationSyntax GetSyntax(string hlslSource, int hierarchyDepth)
+ public static MethodDeclarationSyntax GetSyntax(string hlslSource, int hierarchyDepth, bool useRawMultiLineStringLiteralExpression)
  {
+ SyntaxToken hlslSourceLiteralExpression = useRawMultiLineStringLiteralExpression switch
+ {
+ true => SyntaxTokenHelper.CreateRawMultilineStringLiteral(hlslSource, hierarchyDepth),
+ false => Literal(hlslSource)
+ };
+
  // This code produces a method declaration as follows:
  //
  // readonly void global::ComputeSharp.D2D1.__Internals.ID2D1Shader.BuildHlslSource(out string hlslSource)
@@ -38,9 +46,7 @@ public static MethodDeclarationSyntax GetSyntax(string hlslSource, int hierarchy
  AssignmentExpression(
  SyntaxKind.SimpleAssignmentExpression,
  IdentifierName("hlslSource"),
- LiteralExpression(
- SyntaxKind.StringLiteralExpression,
- SyntaxTokenHelper.CreateRawMultilineStringLiteral(hlslSource, hierarchyDepth))))));
+ LiteralExpression(SyntaxKind.StringLiteralExpression, hlslSourceLiteralExpression)))));
  }
  }
 }

src/ComputeSharp.D2D1.SourceGenerators/ID2D1ShaderGenerator.cs

@@ -208,18 +208,24 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  context.AddSource($"{item.Info.Hierarchy.FilenameHint}.{nameof(LoadDispatchData)}.g.cs", compilationUnit.GetText(Encoding.UTF8));
  });
 
- // Get the BuildHlslSource() info (hierarchy and HLSL source)
- IncrementalValuesProvider<(HierarchyInfo Hierarchy, string HlslSource)> hlslSourceInfo =
+ // Check whether raw multiline string literals can be used (C# 11)
+ IncrementalValueProvider<bool> canUseRawMultilineStringLiterals =
+ context.ParseOptionsProvider
+ .Select((item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp11 });
+
+ // Get the BuildHlslSource() info (hierarchy, HLSL source and parsing options)
+ IncrementalValuesProvider<((HierarchyInfo Hierarchy, string HlslSource) Info, bool CanUseRawMultilineStringLiterals)> hlslSourceInfo =
  shaderInfoWithErrors
- .Select(static (item, _) => (item.Hierarchy, item.HlslShaderSource.HlslSource));
+ .Select(static (item, _) => (item.Hierarchy, item.HlslShaderSource.HlslSource))
+ .Combine(canUseSkipLocalsInit);
 
  // Generate the BuildHlslSource() methods
  context.RegisterSourceOutput(hlslSourceInfo, static (context, item) =>
  {
- MethodDeclarationSyntax buildHlslStringMethod = BuildHlslSource.GetSyntax(item.HlslSource, item.Hierarchy.Hierarchy.Length);
- CompilationUnitSyntax compilationUnit = GetCompilationUnitFromMethod(item.Hierarchy, buildHlslStringMethod, canUseSkipLocalsInit: false);
+ MethodDeclarationSyntax buildHlslStringMethod = BuildHlslSource.GetSyntax(item.Info.HlslSource, item.Info.Hierarchy.Hierarchy.Length, item.CanUseRawMultilineStringLiterals);
+ CompilationUnitSyntax compilationUnit = GetCompilationUnitFromMethod(item.Info.Hierarchy, buildHlslStringMethod, canUseSkipLocalsInit: false);
 
- context.AddSource($"{item.Hierarchy.FilenameHint}.{nameof(BuildHlslSource)}.g.cs", compilationUnit.GetText(Encoding.UTF8));
+ context.AddSource($"{item.Info.Hierarchy.FilenameHint}.{nameof(BuildHlslSource)}.g.cs", compilationUnit.GetText(Encoding.UTF8));
  });
 
  // Get a filtered sequence to enable caching for the HLSL source info, before the shader compilation step

src/ComputeSharp.SourceGeneration/ComputeSharp.SourceGeneration.projitems

@@ -10,6 +10,7 @@
  </PropertyGroup>
  <ItemGroup>
  <Compile Include="$(MSBuildThisFileDirectory)Extensions\AttributeDataExtensions.cs" />
+ <Compile Include="$(MSBuildThisFileDirectory)Extensions\IncrementalValueProviderExtensions.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)Extensions\CompilationExtensions.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)Extensions\DiagnosticsExtensions.cs" />
  <Compile Include="$(MSBuildThisFileDirectory)Extensions\HashCodeExtensions.cs" />

src/ComputeSharp.SourceGeneration/Extensions/IncrementalValueProviderExtensions.cs

@@ -0,0 +1,35 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis;
+
+namespace ComputeSharp.SourceGeneration.Extensions;
+
+/// <summary>
+/// Extension methods for the <see cref="IncrementalValueProvider{TValue}"/> type.
+/// </summary>
+internal static class IncrementalValueProviderExtensions
+{
+ /// <summary>
+ /// Combines three <see cref="IncrementalValueProvider{TValue}"/> instances.
+ /// </summary>
+ /// <typeparam name="T1">The type of values produced by the first <see cref="IncrementalValueProvider{TValue}"/> input.</typeparam>
+ /// <typeparam name="T2">The type of values produced by the second <see cref="IncrementalValueProvider{TValue}"/> input.</typeparam>
+ /// <typeparam name="T3">The type of values produced by the third <see cref="IncrementalValueProvider{TValue}"/> input.</typeparam>
+ /// <param name="source1">The first <see cref="IncrementalValueProvider{TValue}"/> input.</param>
+ /// <param name="source2">The second <see cref="IncrementalValueProvider{TValue}"/> input.</param>
+ /// <param name="source3">The third <see cref="IncrementalValueProvider{TValue}"/> input.</param>
+ /// <returns>The resulting combined <see cref="IncrementalValueProvider{TValue}"/> result.</returns>
+ public static IncrementalValueProvider<(T1, T2, T3)> Combine<T1, T2, T3>(
+ this IncrementalValueProvider<T1> source1,
+ IncrementalValueProvider<T2> source2,
+ IncrementalValueProvider<T3> source3)
+ {
+ return
+ source1
+ .Combine(source2)
+ .Combine(source3)
+ .Select(static (items, _) => (items.Left.Left, items.Left.Right, items.Right));
+ }
+}

src/ComputeSharp.SourceGenerators/IShaderGenerator.CreateBuildHlslSourceMethod.Syntax.cs

@@ -4,6 +4,7 @@
 using ComputeSharp.__Internals;
 using ComputeSharp.SourceGeneration.Helpers;
 using ComputeSharp.SourceGenerators.Models;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
@@ -24,12 +25,13 @@ partial class BuildHlslSource
  /// <param name="hlslSourceInfo">The input <see cref="HlslShaderSourceInfo"/> instance to use.</param>
  /// <param name="supportsDynamicShaders">Indicates whether or not dynamic shaders are supported.</param>
  /// <param name="hierarchyDepth">The depth of the hierarchy for this type (used to calculate the right indentation).</param>
+ /// <param name="useRawMultiLineStringLiteralExpression">Whether to use a raw multiline string literal expression</param>
  /// <returns>The resulting <see cref="MethodDeclarationSyntax"/> instance for the <c>BuildHlslSource</c> method.</returns>
- public static MethodDeclarationSyntax GetSyntax(HlslShaderSourceInfo hlslSourceInfo, bool supportsDynamicShaders, int hierarchyDepth)
+ public static MethodDeclarationSyntax GetSyntax(HlslShaderSourceInfo hlslSourceInfo, bool supportsDynamicShaders, int hierarchyDepth, bool useRawMultiLineStringLiteralExpression)
  {
  // Generate the necessary body statements depending on whether dynamic shaders are supported
  ImmutableArray<StatementSyntax> bodyStatements = supportsDynamicShaders
- ? GenerateRenderMethodBody(hlslSourceInfo, hierarchyDepth)
+ ? GenerateRenderMethodBody(hlslSourceInfo, hierarchyDepth, useRawMultiLineStringLiteralExpression)
  : GenerateEmptyMethodBody();
 
  // This code produces a method declaration as follows:
@@ -81,8 +83,9 @@ private static ImmutableArray<StatementSyntax> GenerateEmptyMethodBody()
  /// </summary>
  /// <param name="hlslSourceInfo">The input <see cref="HlslShaderSourceInfo"/> instance to use.</param>
  /// <param name="hierarchyDepth">The depth of the hierarchy for this type (used to calculate the right indentation).</param>
+ /// <param name="useRawMultiLineStringLiteralExpression">Whether to use a raw multiline string literal expression</param>
  /// <returns>The series of statements to build the HLSL source to compile to execute the current shader.</returns>
- private static ImmutableArray<StatementSyntax> GenerateRenderMethodBody(HlslShaderSourceInfo hlslSourceInfo, int hierarchyDepth)
+ private static ImmutableArray<StatementSyntax> GenerateRenderMethodBody(HlslShaderSourceInfo hlslSourceInfo, int hierarchyDepth, bool useRawMultiLineStringLiteralExpression)
  {
  using ImmutableArrayBuilder<StatementSyntax> statements = ImmutableArrayBuilder<StatementSyntax>.Rent();
 
@@ -112,19 +115,23 @@ void FlushText()
  {
  if (textBuilder.Length > 0)
  {
- string text = textBuilder.ToString();
+ string hlslSource = textBuilder.ToString();
 
- textBuilder.Append(text);
+ textBuilder.Append(hlslSource);
 
  sizeHint += textBuilder.Length;
 
+ SyntaxToken hlslSourceLiteralExpression = useRawMultiLineStringLiteralExpression switch
+ {
+ true => SyntaxTokenHelper.CreateRawMultilineStringLiteral(hlslSource, hierarchyDepth),
+ false => Literal(hlslSource)
+ };
+
  statements.Add(
  ExpressionStatement(
  InvocationExpression(
  MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, IdentifierName("builder"), IdentifierName("Append")))
- .AddArgumentListArguments(Argument(LiteralExpression(
- SyntaxKind.StringLiteralExpression,
- SyntaxTokenHelper.CreateRawMultilineStringLiteral(text, hierarchyDepth))))));
+ .AddArgumentListArguments(Argument(LiteralExpression(SyntaxKind.StringLiteralExpression, hlslSourceLiteralExpression)))));
 
  textBuilder.Clear();
  }

src/ComputeSharp.SourceGenerators/IShaderGenerator.cs

@@ -154,16 +154,21 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
  context.AddSource($"{item.Info.Hierarchy.FilenameHint}.{nameof(LoadDispatchData)}.g.cs", compilationUnit.GetText(Encoding.UTF8));
  });
 
+ // Check whether raw multiline string literals can be used (C# 11)
+ IncrementalValueProvider<bool> canUseRawMultilineStringLiterals =
+ context.ParseOptionsProvider
+ .Select((item, _) => item is CSharpParseOptions { LanguageVersion: >= LanguageVersion.CSharp11 });
+
  // Get the BuildHlslSource info (hierarchy, HLSL source and parsing options)
- IncrementalValuesProvider<((HierarchyInfo Hierarchy, HlslShaderSourceInfo HlslShaderSource) Info, (bool CanUseSkipLocalsInit, bool SupportsDynamicShaders) Options)> hlslSourceInfo =
+ IncrementalValuesProvider<((HierarchyInfo Hierarchy, HlslShaderSourceInfo HlslShaderSource) Info, (bool CanUseSkipLocalsInit, bool SupportsDynamicShaders, bool CanUseRawMultilineStringLiterals) Options)> hlslSourceInfo =
  shaderInfoWithErrors
  .Select(static (item, _) => (item.Hierarchy, item.HlslShaderSource))
- .Combine(canUseSkipLocalsInit.Combine(supportsDynamicShaders));
+ .Combine(canUseSkipLocalsInit.Combine(supportsDynamicShaders, canUseRawMultilineStringLiterals));
 
  // Generate the BuildHlslSource() methods
  context.RegisterSourceOutput(hlslSourceInfo, static (context, item) =>
  {
- MethodDeclarationSyntax buildHlslStringMethod = BuildHlslSource.GetSyntax(item.Info.HlslShaderSource, item.Options.SupportsDynamicShaders, item.Info.Hierarchy.Hierarchy.Length);
+ MethodDeclarationSyntax buildHlslStringMethod = BuildHlslSource.GetSyntax(item.Info.HlslShaderSource, item.Options.SupportsDynamicShaders, item.Info.Hierarchy.Hierarchy.Length, item.Options.CanUseRawMultilineStringLiterals);
  CompilationUnitSyntax compilationUnit = GetCompilationUnitFromMethod(item.Info.Hierarchy, buildHlslStringMethod, item.Options.CanUseSkipLocalsInit);
 
  context.AddSource($"{item.Info.Hierarchy.FilenameHint}.{nameof(BuildHlslSource)}.g.cs", compilationUnit.GetText(Encoding.UTF8));