fix: don't expand value tuples

Author: PawelGerr

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/StringBuilderExtensions.cs

@@ -541,7 +541,7 @@ private static StringBuilder AppendTypeForXmlComment(
          return sb;
       }
 
-      var hasProblematicCharsForXmlDocs = qualifiedTypeName.IndexOfAny(['<', '[', '?']) > -1;
+      var hasProblematicCharsForXmlDocs = qualifiedTypeName.IndexOfAny(['<', '[', '?', '(']) > -1;
 
       if (hasProblematicCharsForXmlDocs)
       {

src/Thinktecture.Runtime.Extensions.SourceGenerator/Extensions/TypeSymbolExtensions.cs

@@ -9,8 +9,7 @@ namespace Thinktecture;
 public static class TypeSymbolExtensions
 {
    private static readonly SymbolDisplayFormat _fullyQualifiedDisplayFormat = SymbolDisplayFormat.FullyQualifiedFormat
-                                                                                                 .AddMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier)
-                                                                                                 .AddMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.ExpandValueTuple);
+                                                                                                 .AddMiscellaneousOptions(SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier);
 
    public static string ToFullyQualifiedDisplayString(this ITypeSymbol type)
    {

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/Extensions/NamedTypeSymbolExtensionsTests/GetValidateFactoryArgumentsReturnType.cs

@@ -238,7 +238,7 @@ public class MyClass
       var result = type.GetValidateFactoryArgumentsReturnType();
 
       result.Should().NotBeNull();
-      result.Should().Be("global::System.ValueTuple<string, int>");
+      result.Should().Be("(string, int)");
    }
 
    [Fact]

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/Extensions/TypeSymbolExtensionsTests/ToFullyQualifiedDisplayString.cs

@@ -537,7 +537,7 @@ public class MyClass
 
       var result = type.ToFullyQualifiedDisplayString();
 
-      result.Should().Be("global::System.ValueTuple<int, string>");
+      result.Should().Be("(int, string)");
    }
 
    [Fact]
@@ -558,7 +558,7 @@ public class MyClass
 
       var result = type.ToFullyQualifiedDisplayString();
 
-      result.Should().Be("global::System.ValueTuple<int, string>");
+      result.Should().Be("(int Id, string Name)");
    }
 
    [Fact]

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/AdHocUnionSourceGeneratorTests.Should_generate_class_with_tuple_types_file=Thinktecture.Tests.TestUnion.AdHocUnion.g.cs.verified.txt

@@ -15,19 +15,19 @@ namespace Thinktecture.Tests
       {
          MemberTypes = new global::System.Collections.Generic.List<global::System.Type>
                        {
-                           typeof(global::System.ValueTuple<int, string>),
+                           typeof((int, string)),
                            typeof(bool)
                        }
                        .AsReadOnly()
       };
 
       private readonly int _valueIndex;
 
-      private readonly global::System.ValueTuple<int, string> _valueTupleOfInt32String;
+      private readonly (int, string) _valueTupleOfInt32String;
       private readonly bool _boolean;
 
       /// <summary>
-      /// Indication whether the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.
+      /// Indication whether the current value is of type <c>(int, string)</c>.
       /// </summary>
       public bool IsValueTupleOfInt32String => this._valueIndex == 1;
 
@@ -37,10 +37,10 @@ namespace Thinktecture.Tests
       public bool IsBoolean => this._valueIndex == 2;
 
       /// <summary>
-      /// Gets the current value as <c>global::System.ValueTuple&lt;int, string&gt;</c>.
+      /// Gets the current value as <c>(int, string)</c>.
       /// </summary>
-      /// <exception cref="global::System.InvalidOperationException">If the current value is not of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</exception>
-      public global::System.ValueTuple<int, string> AsValueTupleOfInt32String => IsValueTupleOfInt32String ? this._valueTupleOfInt32String : throw new global::System.InvalidOperationException($"'{nameof(global::Thinktecture.Tests.TestUnion)}' is not of type '(int, string)'.");
+      /// <exception cref="global::System.InvalidOperationException">If the current value is not of type <c>(int, string)</c>.</exception>
+      public (int, string) AsValueTupleOfInt32String => IsValueTupleOfInt32String ? this._valueTupleOfInt32String : throw new global::System.InvalidOperationException($"'{nameof(global::Thinktecture.Tests.TestUnion)}' is not of type '(int, string)'.");
 
       /// <summary>
       /// Gets the current value as <see cref="bool"/>.
@@ -62,7 +62,7 @@ namespace Thinktecture.Tests
       /// Initializes new instance with <paramref name="valueTupleOfInt32String"/>.
       /// </summary>
       /// <param name="valueTupleOfInt32String">Value to create a new instance for.</param>
-      public TestUnion(global::System.ValueTuple<int, string> @valueTupleOfInt32String)
+      public TestUnion((int, string) @valueTupleOfInt32String)
       {
          this._valueTupleOfInt32String = @valueTupleOfInt32String;
          this._valueIndex = 1;
@@ -82,11 +82,11 @@ namespace Thinktecture.Tests
       /// <summary>
       /// Executes an action depending on the current value.
       /// </summary>
-      /// <param name="valueTupleOfInt32String">The action to execute if the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</param>
+      /// <param name="valueTupleOfInt32String">The action to execute if the current value is of type <c>(int, string)</c>.</param>
       /// <param name="boolean">The action to execute if the current value is of type <see cref="bool"/>.</param>
       [global::System.Diagnostics.DebuggerStepThroughAttribute]
       public void Switch(
-         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<global::System.ValueTuple<int, string>> @valueTupleOfInt32String,
+         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<(int, string)> @valueTupleOfInt32String,
          [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<bool> @boolean)
       {
          switch (this._valueIndex)
@@ -108,12 +108,12 @@ namespace Thinktecture.Tests
       /// Executes an action depending on the current value.
       /// </summary>
       /// <param name="state">State to be passed to the callbacks.</param>
-      /// <param name="valueTupleOfInt32String">The action to execute if the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</param>
+      /// <param name="valueTupleOfInt32String">The action to execute if the current value is of type <c>(int, string)</c>.</param>
       /// <param name="boolean">The action to execute if the current value is of type <see cref="bool"/>.</param>
       [global::System.Diagnostics.DebuggerStepThroughAttribute]
       public void Switch<TState>(
          TState @state,
-         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<TState, global::System.ValueTuple<int, string>> @valueTupleOfInt32String,
+         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<TState, (int, string)> @valueTupleOfInt32String,
          [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Action<TState, bool> @boolean)
 #if NET9_0_OR_GREATER
 		where TState : allows ref struct
@@ -137,11 +137,11 @@ namespace Thinktecture.Tests
       /// <summary>
       /// Executes a function depending on the current value.
       /// </summary>
-      /// <param name="valueTupleOfInt32String">The function to execute if the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</param>
+      /// <param name="valueTupleOfInt32String">The function to execute if the current value is of type <c>(int, string)</c>.</param>
       /// <param name="boolean">The function to execute if the current value is of type <see cref="bool"/>.</param>
       [global::System.Diagnostics.DebuggerStepThroughAttribute]
       public TResult Switch<TResult>(
-         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<global::System.ValueTuple<int, string>, TResult> @valueTupleOfInt32String,
+         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<(int, string), TResult> @valueTupleOfInt32String,
          [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<bool, TResult> @boolean)
 #if NET9_0_OR_GREATER
 		   where TResult : allows ref struct
@@ -164,12 +164,12 @@ namespace Thinktecture.Tests
       /// Executes a function depending on the current value.
       /// </summary>
       /// <param name="state">State to be passed to the callbacks.</param>
-      /// <param name="valueTupleOfInt32String">The function to execute if the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</param>
+      /// <param name="valueTupleOfInt32String">The function to execute if the current value is of type <c>(int, string)</c>.</param>
       /// <param name="boolean">The function to execute if the current value is of type <see cref="bool"/>.</param>
       [global::System.Diagnostics.DebuggerStepThroughAttribute]
       public TResult Switch<TState, TResult>(
          TState @state,
-         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<TState, global::System.ValueTuple<int, string>, TResult> @valueTupleOfInt32String,
+         [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<TState, (int, string), TResult> @valueTupleOfInt32String,
          [global::JetBrains.Annotations.InstantHandleAttribute] global::System.Func<TState, bool, TResult> @boolean)
 #if NET9_0_OR_GREATER
 		   where TResult : allows ref struct
@@ -191,7 +191,7 @@ namespace Thinktecture.Tests
       /// <summary>
       /// Maps current value to an instance of type <typeparamref name="TResult"/>.
       /// </summary>
-      /// <param name="valueTupleOfInt32String">The instance to return if the current value is of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</param>
+      /// <param name="valueTupleOfInt32String">The instance to return if the current value is of type <c>(int, string)</c>.</param>
       /// <param name="boolean">The instance to return if the current value is of type <see cref="bool"/>.</param>
       [global::System.Diagnostics.DebuggerStepThroughAttribute]
       public TResult Map<TResult>(
@@ -213,11 +213,11 @@ namespace Thinktecture.Tests
       }
 
       /// <summary>
-      /// Implicit conversion from type <c>global::System.ValueTuple&lt;int, string&gt;</c>.
+      /// Implicit conversion from type <c>(int, string)</c>.
       /// </summary>
       /// <param name="valueTupleOfInt32String">Value to convert from.</param>
       /// <returns>A new instance of <see cref="TestUnion"/> converted from <paramref name="valueTupleOfInt32String"/>.</returns>
-      public static implicit operator global::Thinktecture.Tests.TestUnion(global::System.ValueTuple<int, string> @valueTupleOfInt32String)
+      public static implicit operator global::Thinktecture.Tests.TestUnion((int, string) @valueTupleOfInt32String)
       {
          return new global::Thinktecture.Tests.TestUnion(@valueTupleOfInt32String);
       }
@@ -233,12 +233,12 @@ namespace Thinktecture.Tests
       }
 
       /// <summary>
-      /// Explicit conversion to type <c>global::System.ValueTuple&lt;int, string&gt;</c>.
+      /// Explicit conversion to type <c>(int, string)</c>.
       /// </summary>
       /// <param name="obj">Object to convert.</param>
-      /// <returns>Inner value of type <c>global::System.ValueTuple&lt;int, string&gt;</c>.</returns>
-      /// <exception cref="System.InvalidOperationException">If the inner value is not a <c>global::System.ValueTuple&lt;int, string&gt;</c>.</exception>
-      public static explicit operator global::System.ValueTuple<int, string>(global::Thinktecture.Tests.TestUnion obj)
+      /// <returns>Inner value of type <c>(int, string)</c>.</returns>
+      /// <exception cref="System.InvalidOperationException">If the inner value is not a <c>(int, string)</c>.</exception>
+      public static explicit operator (int, string)(global::Thinktecture.Tests.TestUnion obj)
       {
          return obj.AsValueTupleOfInt32String;
       }

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/SmartEnumSourceGeneratorTests.Should_generate_delegates_with_named_tuples_file=Thinktecture.Tests.TestEnum.Comparable.g.cs.verified.txt

@@ -0,0 +1,30 @@
+// <auto-generated />
+#nullable enable
+
+namespace Thinktecture.Tests;
+
+partial class TestEnum :
+   global::System.IComparable,
+   global::System.IComparable<global::Thinktecture.Tests.TestEnum>
+{
+   /// <inheritdoc />
+   public int CompareTo(object? obj)
+   {
+      if(obj is null)
+         return 1;
+
+      if(obj is not global::Thinktecture.Tests.TestEnum item)
+         throw new global::System.ArgumentException("Argument must be of type \"TestEnum\".", nameof(obj));
+
+      return this.CompareTo(item);
+   }
+
+   /// <inheritdoc />
+   public int CompareTo(global::Thinktecture.Tests.TestEnum? obj)
+   {
+      if(obj is null)
+         return 1;
+
+      return ((global::System.IComparable<int>)this.Key).CompareTo(obj.Key);
+   }
+}

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/SmartEnumSourceGeneratorTests.Should_generate_delegates_with_named_tuples_file=Thinktecture.Tests.TestEnum.ComparisonOperators.g.cs.verified.txt

@@ -0,0 +1,40 @@
+// <auto-generated />
+#nullable enable
+
+namespace Thinktecture.Tests;
+
+partial class TestEnum :
+   global::System.Numerics.IComparisonOperators<global::Thinktecture.Tests.TestEnum, global::Thinktecture.Tests.TestEnum, bool>
+{
+   /// <inheritdoc cref="global::System.Numerics.IComparisonOperators{TSelf, TOther, TResult}.op_LessThan(TSelf, TOther)" />
+   public static bool operator <(global::Thinktecture.Tests.TestEnum left, global::Thinktecture.Tests.TestEnum right)
+   {
+      global::System.ArgumentNullException.ThrowIfNull(left);
+      global::System.ArgumentNullException.ThrowIfNull(right);
+      return left.Key < right.Key;
+   }
+
+   /// <inheritdoc cref="global::System.Numerics.IComparisonOperators{TSelf, TOther, TResult}.op_LessThanOrEqual(TSelf, TOther)" />
+   public static bool operator <=(global::Thinktecture.Tests.TestEnum left, global::Thinktecture.Tests.TestEnum right)
+   {
+      global::System.ArgumentNullException.ThrowIfNull(left);
+      global::System.ArgumentNullException.ThrowIfNull(right);
+      return left.Key <= right.Key;
+   }
+
+   /// <inheritdoc cref="global::System.Numerics.IComparisonOperators{TSelf, TOther, TResult}.op_GreaterThan(TSelf, TOther)" />
+   public static bool operator >(global::Thinktecture.Tests.TestEnum left, global::Thinktecture.Tests.TestEnum right)
+   {
+      global::System.ArgumentNullException.ThrowIfNull(left);
+      global::System.ArgumentNullException.ThrowIfNull(right);
+      return left.Key > right.Key;
+   }
+
+   /// <inheritdoc cref="global::System.Numerics.IComparisonOperators{TSelf, TOther, TResult}.op_GreaterThanOrEqual(TSelf, TOther)" />
+   public static bool operator >=(global::Thinktecture.Tests.TestEnum left, global::Thinktecture.Tests.TestEnum right)
+   {
+      global::System.ArgumentNullException.ThrowIfNull(left);
+      global::System.ArgumentNullException.ThrowIfNull(right);
+      return left.Key >= right.Key;
+   }
+}

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/SmartEnumSourceGeneratorTests.Should_generate_delegates_with_named_tuples_file=Thinktecture.Tests.TestEnum.EqualityComparisonOperators.g.cs.verified.txt

@@ -0,0 +1,30 @@
+// <auto-generated />
+#nullable enable
+
+namespace Thinktecture.Tests;
+
+partial class TestEnum :
+   global::System.Numerics.IEqualityOperators<global::Thinktecture.Tests.TestEnum, global::Thinktecture.Tests.TestEnum, bool>
+{
+      /// <summary>
+      /// Compares two instances of <see cref="TestEnum"/>.
+      /// </summary>
+      /// <param name="obj">Instance to compare.</param>
+      /// <param name="other">Another instance to compare.</param>
+      /// <returns><c>true</c> if objects are equal; otherwise <c>false</c>.</returns>
+      public static bool operator ==(global::Thinktecture.Tests.TestEnum? obj, global::Thinktecture.Tests.TestEnum? other)
+      {
+         return global::System.Object.ReferenceEquals(obj, other);
+      }
+
+      /// <summary>
+      /// Compares two instances of <see cref="TestEnum"/>.
+      /// </summary>
+      /// <param name="obj">Instance to compare.</param>
+      /// <param name="other">Another instance to compare.</param>
+      /// <returns><c>false</c> if objects are equal; otherwise <c>true</c>.</returns>
+      public static bool operator !=(global::Thinktecture.Tests.TestEnum? obj, global::Thinktecture.Tests.TestEnum? other)
+      {
+         return !(obj == other);
+      }
+}

test/Thinktecture.Runtime.Extensions.SourceGenerator.Tests/SourceGeneratorTests/SmartEnumSourceGeneratorTests.Should_generate_delegates_with_named_tuples_file=Thinktecture.Tests.TestEnum.Formattable.g.cs.verified.txt

@@ -0,0 +1,14 @@
+// <auto-generated />
+#nullable enable
+
+namespace Thinktecture.Tests;
+
+partial class TestEnum :
+   global::System.IFormattable
+{
+   /// <inheritdoc />
+   public string ToString(string? format, global::System.IFormatProvider? formatProvider = null)
+   {
+      return ((global::System.IFormattable)this.Key).ToString(format, formatProvider);
+   }
+}