diff --git a/TUnit.Assertions.Tests/EnumerableTests.cs b/TUnit.Assertions.Tests/EnumerableTests.cs
index 81fbe86bdb..5953e310ac 100644
--- a/TUnit.Assertions.Tests/EnumerableTests.cs
+++ b/TUnit.Assertions.Tests/EnumerableTests.cs
@@ -27,7 +27,7 @@ public async Task Enumerable_Contains_Matcher_Good()
     {
         int[] array = [1, 2, 3];
 
-        await Assert.That(array).Contains((int x) => x == 1);
+        await Assert.That(array).Contains(x => x == 1);
     }
     
     [Test]
@@ -36,7 +36,7 @@ public async Task Enumerable_Contains_Matcher_Bad()
         int[] array = [1, 2, 3];
 
         await Assert.That(
-            async () => await Assert.That(array).Contains((int x) => x == 4)
+            async () => await Assert.That(array).Contains(x => x == 4)
         ).Throws<AssertionException>();
     }
     
@@ -45,7 +45,7 @@ public async Task Enumerable_ContainsOnly_Matcher_Good()
     {
         int[] array = [1, 2, 3];
 
-        await Assert.That(array).ContainsOnly((int x) => x < 10);
+        await Assert.That(array).ContainsOnly(x => x < 10);
     }
     
     [Test]
@@ -54,7 +54,7 @@ public async Task Enumerable_ContainsOnly_Matcher_Bad()
         int[] array = [1, 2, 3];
 
         await Assert.That(
-            async () => await Assert.That(array).ContainsOnly((int x) => x < 3)
+            async () => await Assert.That(array).ContainsOnly(x => x < 3)
         ).Throws<AssertionException>();
     }
     
@@ -81,7 +81,7 @@ public async Task Enumerable_DoesNotContain_Matcher_Good()
     {
         int[] array = [1, 2, 3];
 
-        await Assert.That(array).DoesNotContain((int x) => x > 10);
+        await Assert.That(array).DoesNotContain(x => x > 10);
     }
     
     [Test]
@@ -90,7 +90,7 @@ public async Task Enumerable_DoesNotContain_Matcher_Bad()
         int[] array = [1, 2, 3];
 
         await Assert.That(
-            async () => await Assert.That(array).DoesNotContain((int x) => x < 3)
+            async () => await Assert.That(array).DoesNotContain(x => x < 3)
         ).Throws<AssertionException>();
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions.Tests/TypeInferenceTests.cs b/TUnit.Assertions.Tests/TypeInferenceTests.cs
new file mode 100644
index 0000000000..dfc4cb980b
--- /dev/null
+++ b/TUnit.Assertions.Tests/TypeInferenceTests.cs
@@ -0,0 +1,36 @@
+namespace TUnit.Assertions.Tests;
+
+public class TypeInferenceTests
+{
+    [Test]
+    public async Task Enumerables()
+    {
+        IEnumerable<int> enumerable = [];
+        
+        try
+        {
+            await Assert.That(enumerable)
+                .IsEmpty()
+                .And
+                .IsNotEmpty()
+                .And
+                .Contains(x => x > 1)
+                .And
+                .ContainsOnly(x => x > 1)
+                .And
+                .DoesNotContain(x => x > 1)
+                .And
+                .DoesNotContain(x => x > 1)
+                .And
+                .HasDistinctItems()
+                .And
+                .HasSingleItem()
+                .And.HasCount().EqualTo(0);
+        }
+        catch
+        {
+            // Don't care for assertion failures
+            // Just want to surface any compiler errors if we knock out type inference
+        }
+    }
+}
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/DelegateAnd.cs b/TUnit.Assertions/AssertConditions/Operators/DelegateAnd.cs
index bf7a026655..0d42488211 100644
--- a/TUnit.Assertions/AssertConditions/Operators/DelegateAnd.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/DelegateAnd.cs
@@ -11,21 +11,21 @@ public static DelegateAnd<TActual> Create(AssertionBuilder assertionBuilder)
         return new DelegateAnd<TActual>(assertionBuilder);
     }
 
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
     
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
 
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/DelegateOr.cs b/TUnit.Assertions/AssertConditions/Operators/DelegateOr.cs
index 59049ba78a..7490a80910 100644
--- a/TUnit.Assertions/AssertConditions/Operators/DelegateOr.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/DelegateOr.cs
@@ -11,21 +11,21 @@ public static DelegateOr<TActual> Create(AssertionBuilder assertionBuilder)
         return new DelegateOr<TActual>(assertionBuilder);
     }
     
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
     
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
     
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/ValueAnd.cs b/TUnit.Assertions/AssertConditions/Operators/ValueAnd.cs
index 74efd07c53..d4e3778ee1 100644
--- a/TUnit.Assertions/AssertConditions/Operators/ValueAnd.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/ValueAnd.cs
@@ -11,21 +11,20 @@ public static ValueAnd<TActual> Create(AssertionBuilder assertionBuilder)
         return new ValueAnd<TActual>(assertionBuilder);
     }
     
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
-    
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
 
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/ValueDelegateAnd.cs b/TUnit.Assertions/AssertConditions/Operators/ValueDelegateAnd.cs
index dbbb8d1a75..96c78fc05d 100644
--- a/TUnit.Assertions/AssertConditions/Operators/ValueDelegateAnd.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/ValueDelegateAnd.cs
@@ -11,21 +11,21 @@ public static ValueDelegateAnd<TActual> Create(AssertionBuilder assertionBuilder
         return new ValueDelegateAnd<TActual>(assertionBuilder);
     }
     
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
 
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
     
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/ValueDelegateOr.cs b/TUnit.Assertions/AssertConditions/Operators/ValueDelegateOr.cs
index 683cc7ab9d..d0ff9f69c7 100644
--- a/TUnit.Assertions/AssertConditions/Operators/ValueDelegateOr.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/ValueDelegateOr.cs
@@ -11,21 +11,21 @@ public static ValueDelegateOr<TActual> Create(AssertionBuilder assertionBuilder)
         return new ValueDelegateOr<TActual>(assertionBuilder);
     }
     
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
     
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
     
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
  }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/Operators/ValueOr.cs b/TUnit.Assertions/AssertConditions/Operators/ValueOr.cs
index bb03a2c649..c2d5c7491d 100644
--- a/TUnit.Assertions/AssertConditions/Operators/ValueOr.cs
+++ b/TUnit.Assertions/AssertConditions/Operators/ValueOr.cs
@@ -6,21 +6,21 @@ namespace TUnit.Assertions.AssertConditions.Operators;
 
 public class ValueOr<TActual>(AssertionBuilder assertionBuilder) : IValueSource<TActual>
 {
-    public string? ActualExpression => assertionBuilder.ActualExpression;
+    string? ISource.ActualExpression => ((ISource)assertionBuilder).ActualExpression;
     
-    public Stack<BaseAssertCondition> Assertions => ((ISource)assertionBuilder).Assertions;
-    public ValueTask<AssertionData> AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
-    public StringBuilder ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
+    Stack<BaseAssertCondition> ISource.Assertions => ((ISource)assertionBuilder).Assertions;
+    ValueTask<AssertionData> ISource.AssertionDataTask => ((ISource)assertionBuilder).AssertionDataTask;
+    StringBuilder ISource.ExpressionBuilder => ((ISource)assertionBuilder).ExpressionBuilder;
     
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
-        assertionBuilder.AppendExpression(expression);
+        ((ISource)assertionBuilder).AppendExpression(expression);
         return this;
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
-        assertionBuilder.WithAssertion(assertCondition);
+        ((ISource)assertionBuilder).WithAssertion(assertCondition);
         return this;
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertConditions/SatisfiesAssertCondition.cs b/TUnit.Assertions/AssertConditions/SatisfiesAssertCondition.cs
index 98520bffa6..d0d65abe9d 100644
--- a/TUnit.Assertions/AssertConditions/SatisfiesAssertCondition.cs
+++ b/TUnit.Assertions/AssertConditions/SatisfiesAssertCondition.cs
@@ -37,7 +37,7 @@ protected override async Task<AssertionResult> GetResult(TActual? actualValue, E
 
         var assertion = _assertionBuilder(innerAssertionBuilder);
         
-        foreach (var baseAssertCondition in assertion.Assertions)
+        foreach (var baseAssertCondition in ((ISource)assertion).Assertions)
         {
             var result = await baseAssertCondition.Assert(innerItem, exception, "");
 
diff --git a/TUnit.Assertions/AssertionBuilders/AndAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/AndAssertionBuilder.cs
index 48b1d37432..7c3542021a 100644
--- a/TUnit.Assertions/AssertionBuilders/AndAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/AndAssertionBuilder.cs
@@ -4,9 +4,10 @@
 
 namespace TUnit.Assertions.AssertionBuilders;
 
-public class AndAssertionBuilder<TActual> : AssertionBuilder, IAndAssertionBuilder
+public class AndAssertionBuilder : AssertionBuilder, IAndAssertionBuilder
 {
-    internal AndAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, assertionBuilder.ActualExpression!, (
+    internal AndAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, (
+        (ISource)assertionBuilder).ActualExpression!, (
         (ISource)assertionBuilder).ExpressionBuilder, ((ISource)assertionBuilder).Assertions)
     {
         if (((ISource)assertionBuilder).Assertions.Any(a => a is OrAssertCondition))
diff --git a/TUnit.Assertions/AssertionBuilders/AndConvertedTypeAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/AndConvertedTypeAssertionBuilder.cs
index 63b5fefdae..d691b57277 100644
--- a/TUnit.Assertions/AssertionBuilders/AndConvertedTypeAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/AndConvertedTypeAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using System.Text;
-using TUnit.Assertions.AssertConditions;
+using TUnit.Assertions.AssertConditions;
 using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Assertions.Generics.Conditions;
 
diff --git a/TUnit.Assertions/AssertionBuilders/AssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/AssertionBuilder.cs
index c00092eb95..98a061efeb 100644
--- a/TUnit.Assertions/AssertionBuilders/AssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/AssertionBuilder.cs
@@ -18,7 +18,7 @@ public abstract class AssertionBuilder : ISource
     public AssertionBuilder(ISource source)
     {
         _assertionDataTask = source.AssertionDataTask;
-        ActualExpression = source.ActualExpression;
+        _actualExpression = source.ActualExpression;
         _expressionBuilder = source.ExpressionBuilder;
         _assertions = source.Assertions;
     }
@@ -26,7 +26,7 @@ public AssertionBuilder(ISource source)
     public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string actualExpression, StringBuilder expressionBuilder, Stack<BaseAssertCondition> assertions)
     {
         _assertionDataTask = assertionDataTask;
-        ActualExpression = actualExpression;
+        _actualExpression = actualExpression;
         _expressionBuilder = expressionBuilder;
         _assertions = assertions;
     }
@@ -34,16 +34,16 @@ public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string actua
     public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actualExpression)
     {
         _assertionDataTask = assertionDataTask;
-        ActualExpression = actualExpression;
+        _actualExpression = actualExpression;
         
         if (string.IsNullOrEmpty(actualExpression))
         {
-            ActualExpression = null;
+            _actualExpression = null;
             _expressionBuilder = new StringBuilder("Assert.That(UNKNOWN)");
         }
         else
         {
-            ActualExpression = actualExpression;
+            _actualExpression = actualExpression;
             _expressionBuilder = new StringBuilder("Assert.That(");
             _expressionBuilder.Append(actualExpression);
             _expressionBuilder.Append(')');
@@ -52,7 +52,7 @@ public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actu
 
     StringBuilder ISource.ExpressionBuilder => _expressionBuilder;
 
-    public string? ActualExpression { get; }
+    string? ISource.ActualExpression => _actualExpression;
 
     ValueTask<AssertionData> ISource.AssertionDataTask => _assertionDataTask;
 
@@ -62,8 +62,9 @@ public AssertionBuilder(ValueTask<AssertionData> assertionDataTask, string? actu
     private readonly StringBuilder _expressionBuilder;
     private readonly ValueTask<AssertionData> _assertionDataTask;
     private readonly Stack<BaseAssertCondition> _assertions = new();
+    private readonly string? _actualExpression;
 
-    public ISource AppendExpression(string expression)
+    ISource ISource.AppendExpression(string expression)
     {
         if (!string.IsNullOrEmpty(expression))
         {
@@ -81,7 +82,7 @@ internal AssertionBuilder AppendConnector(ChainType chainType)
             return this;
         }
         
-        return (AssertionBuilder)AppendExpression(chainType.ToString());
+        return (AssertionBuilder)((ISource)this).AppendExpression(chainType.ToString());
     }
     
     protected internal void AppendCallerMethod(string?[] expressions, [CallerMemberName] string methodName = "")
@@ -110,7 +111,7 @@ protected internal void AppendCallerMethod(string?[] expressions, [CallerMemberN
         _expressionBuilder.Append(')');
     }
 
-    public ISource WithAssertion(BaseAssertCondition assertCondition)
+    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
     {
         assertCondition = this switch
         {
diff --git a/TUnit.Assertions/AssertionBuilders/AsyncDelegateAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/AsyncDelegateAssertionBuilder.cs
index bdb90c2c7f..9a029983a7 100644
--- a/TUnit.Assertions/AssertionBuilders/AsyncDelegateAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/AsyncDelegateAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using TUnit.Assertions.AssertConditions;
-using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Extensions;
 
 namespace TUnit.Assertions.AssertionBuilders;
@@ -11,16 +10,4 @@ public class AsyncDelegateAssertionBuilder
     internal AsyncDelegateAssertionBuilder(Func<Task> function, string? expressionBuilder) : base(function.AsAssertionData(expressionBuilder), expressionBuilder)
     {
     }
-    
-    public new ISource AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-
-    public new ISource WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/AsyncValueDelegateAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/AsyncValueDelegateAssertionBuilder.cs
index 2cb6474fff..b1698a4eb2 100644
--- a/TUnit.Assertions/AssertionBuilders/AsyncValueDelegateAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/AsyncValueDelegateAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using TUnit.Assertions.AssertConditions;
-using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Extensions;
 
 namespace TUnit.Assertions.AssertionBuilders;
@@ -10,16 +9,4 @@ public class AsyncValueDelegateAssertionBuilder<TActual>
     internal AsyncValueDelegateAssertionBuilder(Func<Task<TActual>> function, string? expressionBuilder) : base(function.AsAssertionData(expressionBuilder), expressionBuilder)
     {
     }
-
-    public new ISource AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-
-    public new ISource WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
  }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/DelegateAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/DelegateAssertionBuilder.cs
index 4be365cd03..89bdf4ada3 100644
--- a/TUnit.Assertions/AssertionBuilders/DelegateAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/DelegateAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using TUnit.Assertions.AssertConditions;
-using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Extensions;
 
 namespace TUnit.Assertions.AssertionBuilders;
@@ -11,16 +10,4 @@ public class DelegateAssertionBuilder
     internal DelegateAssertionBuilder(Action action, string? expressionBuilder) : base(action.AsAssertionData(expressionBuilder), expressionBuilder)
     {
     }
-    
-    public new ISource AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-
-    public new ISource WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/Groups/AndAssertionGroup.cs b/TUnit.Assertions/AssertionBuilders/Groups/AndAssertionGroup.cs
index b29ac8f980..a8293028a2 100644
--- a/TUnit.Assertions/AssertionBuilders/Groups/AndAssertionGroup.cs
+++ b/TUnit.Assertions/AssertionBuilders/Groups/AndAssertionGroup.cs
@@ -47,7 +47,7 @@ private void Push(TAssertionBuilder assertionBuilder, Func<TAssertionBuilder, In
         if (_assertConditions.Count > 0)
         {
             invokableAssertionBuilder = assert(assertionBuilder);
-            var assertion2 = invokableAssertionBuilder.Assertions.Pop();
+            var assertion2 = ((ISource)invokableAssertionBuilder).Assertions.Pop();
             _assertConditions.Push(new AndAssertCondition(_assertConditions.Pop(), assertion2));
         }
         else
@@ -55,7 +55,7 @@ private void Push(TAssertionBuilder assertionBuilder, Func<TAssertionBuilder, In
             invokableAssertionBuilder = assert(assertionBuilder);
             assertionBuilder.AppendConnector(ChainType.And);
             _invokableAssertionBuilder = invokableAssertionBuilder;
-            _assertConditions.Push(_invokableAssertionBuilder.Assertions.Pop());
+            _assertConditions.Push(((ISource)_invokableAssertionBuilder).Assertions.Pop());
         }
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/Groups/OrAssertionGroup.cs b/TUnit.Assertions/AssertionBuilders/Groups/OrAssertionGroup.cs
index ae8ff9ebea..7429d1a498 100644
--- a/TUnit.Assertions/AssertionBuilders/Groups/OrAssertionGroup.cs
+++ b/TUnit.Assertions/AssertionBuilders/Groups/OrAssertionGroup.cs
@@ -44,14 +44,14 @@ private void Push(TAssertionBuilder assertionBuilder, Func<TAssertionBuilder, In
     {
         if (_assertConditions.Count > 0)
         {
-            _assertConditions.Push(new OrAssertCondition(_assertConditions.Pop(), assert(assertionBuilder).Assertions.Pop()));
+            _assertConditions.Push(new OrAssertCondition(_assertConditions.Pop(), ((ISource)assert(assertionBuilder)).Assertions.Pop()));
         }
         else
         {
             var invokableAssertionBuilder = assert(assertionBuilder);
             assertionBuilder.AppendConnector(ChainType.Or);
             _invokableAssertionBuilder = invokableAssertionBuilder;
-            _assertConditions.Push(_invokableAssertionBuilder.Assertions.Pop());
+            _assertConditions.Push(((ISource)_invokableAssertionBuilder).Assertions.Pop());
         }
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/InvokableAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/InvokableAssertionBuilder.cs
index 4be2b9e1c4..e5a7b8dde0 100644
--- a/TUnit.Assertions/AssertionBuilders/InvokableAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/InvokableAssertionBuilder.cs
@@ -46,17 +46,5 @@ string IInvokableAssertionBuilder.GetExpression()
         return $"{expression[..100]}...";
     }
 
-    public Stack<BaseAssertCondition> Assertions => _source.Assertions;
-
-    public new ISource AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-
-    public new ISource WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
+    protected internal Stack<BaseAssertCondition> Assertions => _source.Assertions;
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/InvokableDelegateAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/InvokableDelegateAssertionBuilder.cs
index d1d5deab2f..1c29e71259 100644
--- a/TUnit.Assertions/AssertionBuilders/InvokableDelegateAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/InvokableDelegateAssertionBuilder.cs
@@ -11,6 +11,6 @@ internal InvokableDelegateAssertionBuilder(InvokableAssertionBuilder<object?> in
 
     public AssertionBuilder AssertionBuilder => this;
     
-    public DelegateAnd<object?> And => new(new AndAssertionBuilder<object?>(AssertionBuilder.AppendConnector(ChainType.And)));
-    public DelegateOr<object?> Or => new(new OrAssertionBuilder<object?>(AssertionBuilder.AppendConnector(ChainType.Or)));
+    public DelegateAnd<object?> And => new(new AndAssertionBuilder(AssertionBuilder.AppendConnector(ChainType.And)));
+    public DelegateOr<object?> Or => new(new OrAssertionBuilder(AssertionBuilder.AppendConnector(ChainType.Or)));
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/InvokableValueAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/InvokableValueAssertionBuilder.cs
index 637429e7d6..95722b3ad9 100644
--- a/TUnit.Assertions/AssertionBuilders/InvokableValueAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/InvokableValueAssertionBuilder.cs
@@ -14,15 +14,15 @@ public class InvokableValueAssertionBuilder<TActual>(ISource source) : Invokable
     public InvokableValueAssertionBuilder<TActual> Because(string reason)
     {
         var becauseReason = new BecauseReason(reason);
-        var assertion = Assertions.Peek();
+        var assertion = source.Assertions.Peek();
         assertion.SetBecauseReason(becauseReason);
         return this;
     }
 
     internal AssertionBuilder AssertionBuilder => this;
     
-    public ValueAnd<TActual> And => new(new AndAssertionBuilder<TActual>(AssertionBuilder.AppendConnector(ChainType.And)));
-    public ValueOr<TActual> Or => new(new OrAssertionBuilder<TActual>(AssertionBuilder.AppendConnector(ChainType.Or)));
+    public ValueAnd<TActual> And => new(new AndAssertionBuilder(AssertionBuilder.AppendConnector(ChainType.And)));
+    public ValueOr<TActual> Or => new(new OrAssertionBuilder(AssertionBuilder.AppendConnector(ChainType.Or)));
     
     public new TaskAwaiter<TActual?> GetAwaiter()
     {
diff --git a/TUnit.Assertions/AssertionBuilders/OrAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/OrAssertionBuilder.cs
index 70e2f65e6c..f768eb99d2 100644
--- a/TUnit.Assertions/AssertionBuilders/OrAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/OrAssertionBuilder.cs
@@ -4,9 +4,10 @@
 
 namespace TUnit.Assertions.AssertionBuilders;
 
-public class OrAssertionBuilder<TActual> : AssertionBuilder, IOrAssertionBuilder
+public class OrAssertionBuilder : AssertionBuilder, IOrAssertionBuilder
 {
-    internal OrAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, assertionBuilder.ActualExpression!, (
+    internal OrAssertionBuilder(AssertionBuilder assertionBuilder) : base(((ISource)assertionBuilder).AssertionDataTask, (
+        (ISource)assertionBuilder).ActualExpression!, (
         (ISource)assertionBuilder).ExpressionBuilder, ((ISource)assertionBuilder).Assertions)
     {
         if (((ISource)assertionBuilder).Assertions.Any(a => a is AndAssertCondition))
diff --git a/TUnit.Assertions/AssertionBuilders/ValueAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/ValueAssertionBuilder.cs
index 60e6f0604b..c70ad4c9ee 100644
--- a/TUnit.Assertions/AssertionBuilders/ValueAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/ValueAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using TUnit.Assertions.AssertConditions;
-using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Extensions;
 
 namespace TUnit.Assertions.AssertionBuilders;
@@ -14,16 +13,4 @@ internal ValueAssertionBuilder(TActual value, string? expressionBuilder) : base(
     public ValueAssertionBuilder(ISource source) : base(source)
     {
     }
-
-    public new ISource AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-    
-    public new ISource WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/AssertionBuilders/ValueDelegateAssertionBuilder.cs b/TUnit.Assertions/AssertionBuilders/ValueDelegateAssertionBuilder.cs
index 317f293a0a..791a1e96cf 100644
--- a/TUnit.Assertions/AssertionBuilders/ValueDelegateAssertionBuilder.cs
+++ b/TUnit.Assertions/AssertionBuilders/ValueDelegateAssertionBuilder.cs
@@ -1,5 +1,4 @@
-using TUnit.Assertions.AssertConditions;
-using TUnit.Assertions.AssertConditions.Interfaces;
+using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.Extensions;
 
 namespace TUnit.Assertions.AssertionBuilders;
@@ -12,16 +11,4 @@ public class ValueDelegateAssertionBuilder<TActual>
     internal ValueDelegateAssertionBuilder(Func<TActual> function, string? expressionBuilder) : base(function.AsAssertionData(expressionBuilder), expressionBuilder)
     {
     }
-
-    ISource ISource.AppendExpression(string expression)
-    {
-        base.AppendExpression(expression);
-        return this;
-    }
-
-    ISource ISource.WithAssertion(BaseAssertCondition assertCondition)
-    {
-        base.WithAssertion(assertCondition);
-        return this;
-    }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/Assertions/Collections/CollectionsIsExtensions.cs b/TUnit.Assertions/Assertions/Collections/CollectionsIsExtensions.cs
index 1fd47c5e1e..cb7f003a51 100644
--- a/TUnit.Assertions/Assertions/Collections/CollectionsIsExtensions.cs
+++ b/TUnit.Assertions/Assertions/Collections/CollectionsIsExtensions.cs
@@ -1,6 +1,5 @@
 #nullable disable
 
-using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using TUnit.Assertions.AssertConditions.Collections;
@@ -43,9 +42,8 @@ public static InvokableValueAssertionBuilder<TActual> IsEquivalentTo<
                 comparer, collectionOrdering), [doNotPopulateThisValue]);
     }
     
-    public static InvokableValueAssertionBuilder<TActual> IsEmpty<TActual>(this IValueSource<TActual> valueSource)
-        where TActual : IEnumerable
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> IsEmpty<TInner>(this IValueSource<IEnumerable<TInner>> valueSource)
     {
-        return valueSource.RegisterAssertion(new EnumerableCountEqualToExpectedValueAssertCondition<TActual>(0), []);
+        return valueSource.RegisterAssertion(new EnumerableCountEqualToExpectedValueAssertCondition<TInner>(0), []);
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/Assertions/Collections/CollectionsIsNotExtensions.cs b/TUnit.Assertions/Assertions/Collections/CollectionsIsNotExtensions.cs
index 4b6a15bd02..58aa0f6ba3 100644
--- a/TUnit.Assertions/Assertions/Collections/CollectionsIsNotExtensions.cs
+++ b/TUnit.Assertions/Assertions/Collections/CollectionsIsNotExtensions.cs
@@ -1,6 +1,5 @@
 #nullable disable
 
-using System.Collections;
 using System.Runtime.CompilerServices;
 using TUnit.Assertions.AssertConditions.Collections;
 using TUnit.Assertions.AssertConditions.Interfaces;
@@ -17,10 +16,9 @@ public static InvokableValueAssertionBuilder<TActual> IsNotEquivalentTo<TActual,
             , [doNotPopulateThisValue]);
     }
     
-    public static InvokableValueAssertionBuilder<TActual> IsNotEmpty<TActual>(this IValueSource<TActual> valueSource)
-        where TActual : IEnumerable
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> IsNotEmpty<TInner>(this IValueSource<IEnumerable<TInner>> valueSource)
     {
-        return valueSource.RegisterAssertion(new EnumerableCountNotEqualToExpectedValueAssertCondition<TActual>(0)
+        return valueSource.RegisterAssertion(new EnumerableCountNotEqualToExpectedValueAssertCondition<TInner>(0)
             , []);
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableAllExpectedFuncAssertCondition.cs b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableAllExpectedFuncAssertCondition.cs
index 137c854caf..a227bc65e8 100644
--- a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableAllExpectedFuncAssertCondition.cs
+++ b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableAllExpectedFuncAssertCondition.cs
@@ -1,11 +1,11 @@
 namespace TUnit.Assertions.AssertConditions.Collections;
 
 public class EnumerableAllExpectedFuncAssertCondition<TActual, TInner>(
-    Func<TInner, bool> matcher, string matcherString)
+    Func<TInner, bool> matcher, string? matcherString)
     : BaseAssertCondition<TActual>
     where TActual : IEnumerable<TInner>
 {
-    protected override string GetExpectation() => $"to contain only entries matching {matcherString}";
+    protected override string GetExpectation() => $"to contain only entries matching {matcherString ?? "null"}";
     
     protected override Task<AssertionResult> GetResult(TActual? actualValue, Exception? exception)
     {
diff --git a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableContainsExpectedFuncAssertCondition.cs b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableContainsExpectedFuncAssertCondition.cs
index a09b24ab55..f81d1dc6ab 100644
--- a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableContainsExpectedFuncAssertCondition.cs
+++ b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableContainsExpectedFuncAssertCondition.cs
@@ -1,11 +1,11 @@
 namespace TUnit.Assertions.AssertConditions.Collections;
 
 public class EnumerableContainsExpectedFuncAssertCondition<TActual, TInner>(
-    Func<TInner, bool> matcher, string matcherString)
+    Func<TInner, bool> matcher, string? matcherString)
     : BaseAssertCondition<TActual>
     where TActual : IEnumerable<TInner>
 {
-    protected override string GetExpectation() => $"to contain an entry matching {matcherString}";
+    protected override string GetExpectation() => $"to contain an entry matching {matcherString ?? "null"}";
     
     protected override Task<AssertionResult> GetResult(TActual? actualValue, Exception? exception)
     {
diff --git a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountEqualToExpectedValueAssertCondition.cs b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountEqualToExpectedValueAssertCondition.cs
index 28cc5b59de..827577c126 100644
--- a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountEqualToExpectedValueAssertCondition.cs
+++ b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountEqualToExpectedValueAssertCondition.cs
@@ -2,24 +2,23 @@
 
 namespace TUnit.Assertions.AssertConditions.Collections;
 
-public class EnumerableCountEqualToExpectedValueAssertCondition<TActual>(int expected)
-    : ExpectedValueAssertCondition<TActual, int>(expected)
-    where TActual : IEnumerable
+public class EnumerableCountEqualToExpectedValueAssertCondition<TInner>(int expected)
+    : ExpectedValueAssertCondition<IEnumerable<TInner>, int>(expected)
 {
     protected override string GetExpectation() => $"to have a count of {expected}";
 
-    protected override AssertionResult GetResult(TActual? actualValue, int count)
+    protected override AssertionResult GetResult(IEnumerable<TInner>? actualValue, int count)
     {
         var actualCount = GetCount(actualValue);
 
         return AssertionResult
             .FailIf(actualValue is null,
-                $"{ActualExpression ?? typeof(TActual).Name} is null")
+                $"{ActualExpression ?? typeof(IEnumerable<TInner>).Name} is null")
             .OrFailIf(actualCount != count,
                 $"it was {actualCount} instead");
     }
 
-    private int GetCount(TActual? actualValue)
+    private int GetCount(IEnumerable<TInner>? actualValue)
     {
         if (actualValue is ICollection collection)
         {
diff --git a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountNotEqualToExpectedValueAssertCondition.cs b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountNotEqualToExpectedValueAssertCondition.cs
index 5c7564a8a5..f0230ecdff 100644
--- a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountNotEqualToExpectedValueAssertCondition.cs
+++ b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableCountNotEqualToExpectedValueAssertCondition.cs
@@ -2,24 +2,23 @@
 
 namespace TUnit.Assertions.AssertConditions.Collections;
 
-public class EnumerableCountNotEqualToExpectedValueAssertCondition<TActual>(int expected)
-    : ExpectedValueAssertCondition<TActual, int>(expected)
-    where TActual : IEnumerable
+public class EnumerableCountNotEqualToExpectedValueAssertCondition<TInner>(int expected)
+    : ExpectedValueAssertCondition<IEnumerable<TInner>, int>(expected)
 {
     protected override string GetExpectation() => $"to have a count different to {expected}";
     
-    protected override AssertionResult GetResult(TActual? actualValue, int count)
+    protected override AssertionResult GetResult(IEnumerable<TInner>? actualValue, int count)
     {
         var actualCount = GetCount(actualValue);
 
         return AssertionResult
             .FailIf(actualValue is null,
-                $"{ActualExpression ?? typeof(TActual).Name} is null")
+                $"{ActualExpression ?? typeof(IEnumerable<TInner>).Name} is null")
             .OrFailIf(actualCount == count,
                 $"it was {actualCount}");
     }
 
-    private int GetCount(TActual? actualValue)
+    private int GetCount(IEnumerable<TInner>? actualValue)
     {
         if (actualValue is ICollection collection)
         {
diff --git a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableDistinctItemsExpectedValueAssertCondition.cs b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableDistinctItemsExpectedValueAssertCondition.cs
index dea1dc73ad..cbb4544f42 100644
--- a/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableDistinctItemsExpectedValueAssertCondition.cs
+++ b/TUnit.Assertions/Assertions/Collections/Conditions/EnumerableDistinctItemsExpectedValueAssertCondition.cs
@@ -1,26 +1,23 @@
-using System.Collections;
-
 namespace TUnit.Assertions.AssertConditions.Collections;
 
-public class EnumerableDistinctItemsExpectedValueAssertCondition<TActual, TInner>(IEqualityComparer<TInner?>? equalityComparer)
-    : BaseAssertCondition<TActual>
-    where TActual : IEnumerable
+public class EnumerableDistinctItemsExpectedValueAssertCondition<TInner>(IEqualityComparer<TInner?>? equalityComparer)
+    : BaseAssertCondition<IEnumerable<TInner>>
 {
     protected override string GetExpectation() => "items to be distinct";
 
-    protected override Task<AssertionResult> GetResult(TActual? actualValue, Exception? exception)
+    protected override Task<AssertionResult> GetResult(IEnumerable<TInner>? actualValue, Exception? exception)
     {
         if (actualValue is null)
         {
-            return AssertionResult.Fail($"{ActualExpression ?? typeof(TActual).Name} is null");
+            return AssertionResult.Fail($"{ActualExpression ?? typeof(IEnumerable<TInner>).Name} is null");
         }
 
-        var list = actualValue.Cast<TInner>().ToList();
+        var list = actualValue.ToArray();
 
         var distinct = list.Distinct(equalityComparer);
 
         return AssertionResult
-            .FailIf(list.Count != distinct.Count(),
+            .FailIf(list.Length != distinct.Count(),
                 "duplicate items found in the collection");
 
     }
diff --git a/TUnit.Assertions/Assertions/Collections/HasExtensions_Enumerable.cs b/TUnit.Assertions/Assertions/Collections/HasExtensions_Enumerable.cs
index 62f49e3fab..58cb88d001 100644
--- a/TUnit.Assertions/Assertions/Collections/HasExtensions_Enumerable.cs
+++ b/TUnit.Assertions/Assertions/Collections/HasExtensions_Enumerable.cs
@@ -1,6 +1,5 @@
 #nullable disable
 
-using System.Collections;
 using TUnit.Assertions.AssertConditions.Collections;
 using TUnit.Assertions.AssertConditions.Interfaces;
 using TUnit.Assertions.AssertionBuilders;
@@ -9,21 +8,20 @@ namespace TUnit.Assertions.Extensions;
 
 public static partial class HasExtensions
 {
-    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> HasSingleItem<TInner>(this IValueSource<IEnumerable<TInner>> valueSource, IEqualityComparer equalityComparer = null) 
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> HasSingleItem<TInner>(this IValueSource<IEnumerable<TInner>> valueSource) 
     {
-        return valueSource.RegisterAssertion(new EnumerableCountEqualToExpectedValueAssertCondition<IEnumerable<TInner>>(1)
+        return valueSource.RegisterAssertion(new EnumerableCountEqualToExpectedValueAssertCondition<TInner>(1)
             , []);
     }
     
-    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> HasDistinctItems<TInner>(this IValueSource<IEnumerable<TInner>> valueSource) 
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> HasDistinctItems<TInner>(this IValueSource<IEnumerable<TInner>> valueSource)
     {
-        return valueSource.RegisterAssertion(new EnumerableDistinctItemsExpectedValueAssertCondition<IEnumerable<TInner>, object>(null)
-            , []);
+        return HasDistinctItems(valueSource, EqualityComparer<TInner>.Default);
     }
     
     public static InvokableValueAssertionBuilder<IEnumerable<TInner>> HasDistinctItems<TInner>(this IValueSource<IEnumerable<TInner>> valueSource, IEqualityComparer<TInner> equalityComparer) 
     {
-        return valueSource.RegisterAssertion(new EnumerableDistinctItemsExpectedValueAssertCondition<IEnumerable<TInner>, TInner>(equalityComparer)
+        return valueSource.RegisterAssertion(new EnumerableDistinctItemsExpectedValueAssertCondition<TInner>(equalityComparer)
             , []);
     }
     
diff --git a/TUnit.Assertions/Assertions/Generics/DoesExtensions_Generic.cs b/TUnit.Assertions/Assertions/Generics/DoesExtensions_Generic.cs
index 2616a64fbc..1a55c6e8c9 100644
--- a/TUnit.Assertions/Assertions/Generics/DoesExtensions_Generic.cs
+++ b/TUnit.Assertions/Assertions/Generics/DoesExtensions_Generic.cs
@@ -16,17 +16,15 @@ public static InvokableValueAssertionBuilder<TActual> Contains<TActual, TInner>(
             , [doNotPopulateThisValue]);
     }
     
-    public static InvokableValueAssertionBuilder<TActual> Contains<TActual, TInner>(this IValueSource<TActual> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string doNotPopulateThisValue = null)
-        where TActual : IEnumerable<TInner>
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> Contains<TInner>(this IValueSource<IEnumerable<TInner>> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string doNotPopulateThisValue = null)
     {
-        return valueSource.RegisterAssertion(new EnumerableContainsExpectedFuncAssertCondition<TActual, TInner>(matcher, doNotPopulateThisValue)
+        return valueSource.RegisterAssertion(new EnumerableContainsExpectedFuncAssertCondition<IEnumerable<TInner>, TInner>(matcher, doNotPopulateThisValue)
             , [doNotPopulateThisValue]);
     }
 
-    public static InvokableValueAssertionBuilder<TActual> ContainsOnly<TActual, TInner>(this IValueSource<TActual> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string doNotPopulateThisValue = null)
-        where TActual : IEnumerable<TInner>
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> ContainsOnly<TInner>(this IValueSource<IEnumerable<TInner>> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string doNotPopulateThisValue = null)
     {
-        return valueSource.RegisterAssertion(new EnumerableAllExpectedFuncAssertCondition<TActual, TInner>(matcher, doNotPopulateThisValue)
+        return valueSource.RegisterAssertion(new EnumerableAllExpectedFuncAssertCondition<IEnumerable<TInner>, TInner>(matcher, doNotPopulateThisValue)
             , [doNotPopulateThisValue]);
     }
 
diff --git a/TUnit.Assertions/Assertions/Generics/DoesNotExtensions_Generic.cs b/TUnit.Assertions/Assertions/Generics/DoesNotExtensions_Generic.cs
index dcba8c092f..a3de649787 100644
--- a/TUnit.Assertions/Assertions/Generics/DoesNotExtensions_Generic.cs
+++ b/TUnit.Assertions/Assertions/Generics/DoesNotExtensions_Generic.cs
@@ -14,10 +14,9 @@ public static InvokableValueAssertionBuilder<TActual> DoesNotContain<TActual, TI
             , [doNotPopulateThisValue]);
     }
 
-    public static InvokableValueAssertionBuilder<TActual> DoesNotContain<TActual, TInner>(this IValueSource<TActual> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string? doNotPopulateThisValue = null)
-        where TActual : IEnumerable<TInner>
+    public static InvokableValueAssertionBuilder<IEnumerable<TInner>> DoesNotContain<TInner>(this IValueSource<IEnumerable<TInner>> valueSource, Func<TInner, bool> matcher, [CallerArgumentExpression(nameof(matcher))] string? doNotPopulateThisValue = null)
     {
-        return valueSource.RegisterAssertion(new EnumerableNotContainsExpectedFuncAssertCondition<TActual, TInner>(matcher, doNotPopulateThisValue)
+        return valueSource.RegisterAssertion(new EnumerableNotContainsExpectedFuncAssertCondition<IEnumerable<TInner>, TInner>(matcher, doNotPopulateThisValue)
             , [doNotPopulateThisValue]);
     }
 }
\ No newline at end of file
diff --git a/TUnit.Assertions/Assertions/Throws/ThrowsException.cs b/TUnit.Assertions/Assertions/Throws/ThrowsException.cs
index 5f862a29a4..2cc00b7b52 100644
--- a/TUnit.Assertions/Assertions/Throws/ThrowsException.cs
+++ b/TUnit.Assertions/Assertions/Throws/ThrowsException.cs
@@ -62,6 +62,6 @@ public AndConvertedTypeAssertionBuilder<TException> And
     private async ValueTask<AssertionData> AssertionDataTask()
     {
         var value = await this;
-        return new AssertionData(value, null, _delegateAssertionBuilder.ActualExpression);
+        return new AssertionData(value, null, ((ISource)_delegateAssertionBuilder).ActualExpression);
     }
 }
\ No newline at end of file