Merge pull request #21 from bmazzarol/feat/support-non-static

feat: allow `static` to be dropped from refinement methods

Author: bmazzarol

Tuxedo.Examples/Examples.cs

@@ -10,7 +10,7 @@ namespace Examples;
 public readonly partial struct PositiveInt
 {
     [Refinement("Must be positive", Name = nameof(PositiveInt))]
-    private static bool IsPositive(int value) => value > 0;
+    private bool IsPositive(int value) => value > 0;
 }
 
 /// <summary>

Tuxedo.Examples/Tuxedo.Examples.csproj

@@ -5,6 +5,7 @@
         <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
+        <IsPackable>false</IsPackable>
     </PropertyGroup>
     <ItemGroup>
         <ProjectReference Include="..\Tuxedo.SourceGenerator\Tuxedo.SourceGenerator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>

Tuxedo.SourceGenerator/Generators/RefinementSourceGenerator.cs

@@ -42,7 +42,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
     private static bool IsRefinementMethod(SyntaxNode s, CancellationToken cancellationToken)
     {
         return s is MethodDeclarationSyntax mds
-            && mds.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword))
+            // the method is either static or within the struct we are refining
+            && IsStaticOrWithinGeneratedType(mds)
             // and returns a bool or a string
             && (
                 string.Equals(mds.ReturnType.ToString(), "bool", StringComparison.Ordinal)
@@ -58,6 +59,24 @@ private static bool IsRefinementMethod(SyntaxNode s, CancellationToken cancellat
             );
     }
 
+    private static bool IsStaticOrWithinGeneratedType(MethodDeclarationSyntax mds)
+    {
+        var attributeParts = new RefinementAttributeParts(mds);
+        return
+            // either the method is static
+            mds.Modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword))
+            // or the method is within the struct we are refining
+            || mds.Ancestors()
+                .OfType<StructDeclarationSyntax>()
+                .Any(tds =>
+                    string.Equals(
+                        tds.Identifier.Text,
+                        attributeParts.Name,
+                        StringComparison.Ordinal
+                    )
+                );
+    }
+
     private static RefinedTypeDetails BuildRefinedTypeDetails(
         GeneratorAttributeSyntaxContext ctx,
         CancellationToken token
@@ -87,7 +106,8 @@ CancellationToken token
         var containingType = methodSymbol.ContainingType;
         var @class = containingType.ToDisplayString();
         var name = methodDeclarationSyntax.Identifier.Text;
-        var predicate = $"{@class}.{name}";
+        var isStatic = methodSymbol.IsStatic;
+        var predicate = isStatic ? $"{@class}.{name}" : name;
 
         // get the attribute details
         var attributeParts = new RefinementAttributeParts(methodDeclarationSyntax);

Tuxedo.Tests/OddNumberExample.Case8#Odd.g.verified.cs

@@ -0,0 +1,125 @@
+//HintName: Odd.g.cs
+// <auto-generated/>
+#nullable enable
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using Tuxedo;
+
+namespace <global namespace>;
+
+/// <summary>
+/// A refined T based on the IsValid refinement predicate
+/// </summary>
+[RefinedType]
+public readonly partial struct Odd<T> : IEquatable<Odd<T>>
+	where T : INumberBase<T>
+{
+    private readonly T? _value;
+   
+    /// <summary>
+    /// The underlying T
+    /// </summary>
+    public T Value => _value ?? throw new InvalidOperationException("Do not use the default value, please use the Parse and TryParse methods to construct a Odd");
+
+    /// <summary>
+    /// Implicit conversion from the Odd&lt;T&gt; to a T
+    /// </summary>
+    /// <param name="this">the Odd&lt;T&gt;</param>
+    /// <returns>underlying T</returns>
+    public static implicit operator T(Odd<T> @this)
+    {
+        return @this.Value;
+    }
+    
+    private Odd(T value)
+    {
+        _value = value;
+    }
+
+    /// <summary>
+    /// Explicit conversion from a T to a Odd&lt;T&gt;
+    /// </summary>
+    /// <param name="value">raw T</param>
+    /// <returns>refined Odd&lt;T&gt;</returns>
+    /// <exception cref="ArgumentOutOfRangeException">if the IsValid refinement fails</exception>
+    public static explicit operator Odd<T>(T value)
+    {
+        return Parse(value);
+    }
+    
+    /// <summary>
+    /// Refines the T or throws
+    /// </summary>
+    /// <param name="value">raw T</param>
+    /// <returns>refined Odd&lt;T&gt;</returns>
+    /// <exception cref="ArgumentOutOfRangeException">if the IsValid refinement fails</exception>
+    public static Odd<T> Parse(T value)
+    {
+        return TryParse(value, out var result, out var failureMessage) ? result : throw new ArgumentOutOfRangeException(nameof(value), value, failureMessage);
+    }
+    
+    /// <summary>
+    /// Try and refine the T against the IsValid refinement
+    /// </summary>
+    /// <param name="value">raw T</param>
+    /// <param name="refined">refined Odd&lt;T&gt; when true</param>
+    /// <param name="failureMessage">error message when false</param>
+    /// <returns>true if refined, false otherwise</returns>
+    public static bool TryParse(
+        T value,
+        out Odd<T> refined,
+        [NotNullWhen(false)] out string? failureMessage
+    )
+    {
+        if (IsValid(value))
+        {
+            refined = new Odd<T>(value);
+            failureMessage = null;
+            return true;
+        }
+        
+        refined = default;
+        failureMessage = $"The number must be an odd number, but was '{value}'";
+        return false;
+    }
+    
+    // <inheritdoc />
+    public bool Equals(Odd<T> other)
+    {
+        return Nullable.Equals(_value, other._value);
+    }
+    
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+    {
+        return obj is Odd<T> other && Equals(other);
+    }
+    
+    /// <inheritdoc />
+    public static bool operator ==(Odd<T> left, Odd<T> right)
+    {
+        return left.Equals(right);
+    }
+    
+    /// <inheritdoc />
+    public static bool operator !=(Odd<T> left, Odd<T> right)
+    {
+        return !(left == right);
+    }
+    
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(_value);
+    }
+    
+    /// <summary>
+    /// Returns the string representation of the underlying T
+    /// </summary>
+    public override string ToString()
+    {
+        return Value.ToString() ?? string.Empty;
+    }
+}

Tuxedo.Tests/OddNumberExample.cs

@@ -113,4 +113,23 @@ public readonly partial struct Odd<T>
             """.BuildDriver();
         return Verify(driver).IgnoreStandardSupportCode();
     }
+
+    [Fact(
+        DisplayName = "OddT refinement snapshot is correct with generics and constraints on the class and no static modifier"
+    )]
+    public Task Case8()
+    {
+        var driver = """
+            using Tuxedo;
+            using System.Numerics;
+
+            public readonly partial struct Odd<T>
+               where T : INumberBase<T>
+            {
+               [Refinement("The number must be an odd number, but was '{value}'", Name = "Odd")]
+               private bool IsValid(T value) => T.IsOddInteger(value);
+            }
+            """.BuildDriver();
+        return Verify(driver).IgnoreStandardSupportCode();
+    }
 }