Refactor the source generator to be public

.editorconfig

@@ -12,7 +12,7 @@ indent_style = space
 tab_width = 4
 
 # New line preferences
-end_of_line = crlf
+# end_of_line = crlf
 insert_final_newline = false
 
 #### .NET Coding Conventions ####
@@ -58,7 +58,7 @@ dotnet_style_prefer_is_null_check_over_reference_equality_method = true:error
 dotnet_style_readonly_field = true:error
 
 # Parameter preferences
-dotnet_code_quality_unused_parameters = all:error
+dotnet_code_quality_unused_parameters = all:warning
 
 #### C# Coding Conventions ####
 
@@ -68,14 +68,14 @@ csharp_style_var_for_built_in_types = true:error
 csharp_style_var_when_type_is_apparent = true:error
 
 # Expression-bodied members
-csharp_style_expression_bodied_accessors = true:error
-csharp_style_expression_bodied_constructors = true:error
-csharp_style_expression_bodied_indexers = true:error
-csharp_style_expression_bodied_lambdas = true:error
-csharp_style_expression_bodied_local_functions = true:error
-csharp_style_expression_bodied_methods = true:error
-csharp_style_expression_bodied_operators = true:error
-csharp_style_expression_bodied_properties = true:error
+csharp_style_expression_bodied_accessors =true:warning
+csharp_style_expression_bodied_constructors =true:warning
+csharp_style_expression_bodied_indexers =true:warning
+csharp_style_expression_bodied_lambdas =true:warning
+csharp_style_expression_bodied_local_functions =true:warning
+csharp_style_expression_bodied_methods =true:warning
+csharp_style_expression_bodied_operators =true:warning
+csharp_style_expression_bodied_properties =true:warning
 
 # Pattern matching preferences
 csharp_style_pattern_matching_over_as_with_null_check = true:error
@@ -101,7 +101,7 @@ csharp_style_pattern_local_over_anonymous_function = true:error
 csharp_style_prefer_index_operator = true:warning
 csharp_style_prefer_range_operator = true:warning
 csharp_style_throw_expression = true:error
-csharp_style_unused_value_assignment_preference = discard_variable:error
+csharp_style_unused_value_assignment_preference =discard_variable:warning
 csharp_style_unused_value_expression_statement_preference = discard_variable:error
 
 # 'using' directive preferences

.gitattributes

@@ -1,7 +1,7 @@
 ###############################################################################
 # Set default behavior to automatically normalize line endings.
 ###############################################################################
-* text=auto
+* text eol=lf
 
 ###############################################################################
 # Set default behavior for command prompt diff.

.github/workflows/dotnetcore.yml

@@ -10,20 +10,21 @@ jobs:
     - name: Check out repository
       uses: actions/checkout@v2
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1.7.2
+      uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: '6.0.100-preview.2.21155.3'
+        dotnet-version: '6.0.x'
+        include-prerelease: true
     - name: Test source generator
-      run: dotnet test ./NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj 
+      run: dotnet test ./NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj 
     - name: Build solution
       run: dotnet build
     - name: Tests and coverage
-      run: dotnet test ./NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj -f:net6.0 -p:CollectCoverage=true -p:CoverletOutputFormat=lcov -p:CoverletOutput=TestResults/
+      run: dotnet test ./NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj -f:net6.0 -p:CollectCoverage=true -p:CoverletOutputFormat=lcov -p:CoverletOutput=TestResults/
     - name: Publish coverage report to coveralls.io
       uses: coverallsapp/github-action@master
       with:
         github-token: ${{ secrets.GITHUB_TOKEN }}
-        path-to-lcov: ./NetFabric.Hyperlinq.UnitTests/TestResults/coverage.net6.0.info
+        path-to-lcov: ./NetFabric.Hyperlinq.Core.UnitTests/TestResults/coverage.net6.0.info
 
 
 

NetFabric.Hyperlinq.Benchmarks/NetFabric.Hyperlinq.Benchmarks.csproj

@@ -3,18 +3,13 @@
     <OutputType>Exe</OutputType>
     <TargetFrameworks>net6.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-
-  <PropertyGroup>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <DebugSymbols>true</DebugSymbols>
+    <Configuration>Release</Configuration>
+    <DebugSymbols>false</DebugSymbols>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\NetFabric.Hyperlinq\NetFabric.Hyperlinq.csproj" />
-    <ProjectReference Include="..\NetFabric.Hyperlinq.UnitTests\NetFabric.Hyperlinq.UnitTests.csproj" />
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Core.UnitTests\NetFabric.Hyperlinq.Core.UnitTests.csproj" />
   </ItemGroup>
 
   <ItemGroup>

NetFabric.Hyperlinq.SourceGenerator.UnitTests/NetFabric.Hyperlinq.SourceGenerator.UnitTests.csproj → NetFabric.Hyperlinq.Core.UnitTests/NetFabric.Hyperlinq.Core.UnitTests.csproj

@@ -1,34 +1,36 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
-
+    <TargetFrameworks>net48;netcoreapp2.1;netcoreapp3.1;net6.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
-
+  
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.10.0" />
+    <PackageReference Include="coverlet.msbuild" Version="3.0.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.10.0" />
     <PackageReference Include="NetFabric.Assertive" Version="3.0.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    <PackageReference Include="NetFabric.Hyperlinq.Analyzer" Version="2.0.3">
       <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="3.0.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.Collections.Immutable" Version="5.0.0" />
+    <PackageReference Include="System.Interactive" Version="5.0.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\NetFabric.Hyperlinq.SourceGenerator\NetFabric.Hyperlinq.SourceGenerator.csproj" />
+    <ProjectReference Include="..\NetFabric.Hyperlinq.Core\NetFabric.Hyperlinq.Core.csproj" />
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Update="TestData\**">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-    </Compile>
+    <DotNetCliToolReference Include="dotnet-reportgenerator-cli" Version="4.3.8" />
   </ItemGroup>
 
 </Project>

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncEnumerable.cs

@@ -28,11 +28,7 @@ public AsyncEnumerator<T> GetAsyncEnumerator()
             IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken _) 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => new AsyncEnumerator<T>(source);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public AsyncEnumerableExtensions.AsyncValueEnumerable<AsyncEnumerableWrapper<T>, AsyncEnumerator<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction, GetAsyncEnumeratorFunction> AsAsyncValueEnumerable()
-                => this.AsAsyncValueEnumerable<AsyncEnumerableWrapper<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction>();
-
+
             public readonly struct GetAsyncEnumeratorFunction
                 : IFunction<AsyncEnumerableWrapper<T>, CancellationToken, AsyncEnumerator<T>>
             {

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsAsyncValueEnumerable.cs

@@ -31,10 +31,6 @@ AsyncEnumerator<T> IAsyncValueEnumerable<T, AsyncEnumerator<T>>.GetAsyncEnumerat
             IAsyncEnumerator<T> IAsyncEnumerable<T>.GetAsyncEnumerator(CancellationToken _) 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => new AsyncEnumerator<T>(source);
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public AsyncValueEnumerableExtensions.AsyncValueEnumerable<AsyncValueEnumerableWrapper<T>, AsyncEnumerator<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction, GetAsyncEnumeratorFunction> AsAsyncValueEnumerable()
-                => AsyncValueEnumerableExtensions.AsAsyncValueEnumerable<AsyncValueEnumerableWrapper<T>, AsyncEnumerator<T>, T, GetAsyncEnumeratorFunction>(this);
 
             public readonly struct GetAsyncEnumeratorFunction
                 : IFunction<AsyncValueEnumerableWrapper<T>, CancellationToken, AsyncEnumerator<T>>

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsEnumerable.cs

@@ -31,10 +31,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public EnumerableExtensions.ValueEnumerable<EnumerableWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => this.AsValueEnumerable<EnumerableWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>();
 
             public readonly struct GetEnumeratorFunction
                 : IFunction<EnumerableWrapper<T>, Enumerator<T>>

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyCollection.cs

@@ -24,16 +24,6 @@ public ReadOnlyCollectionWrapper(T[] source)
 
             public int Count 
                 => source.Length;
-
-            public new ReadOnlyCollectionExtensions.ValueEnumerable<ReadOnlyCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ReadOnlyCollectionExtensions.AsValueEnumerable<ReadOnlyCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-
-            public new readonly struct GetEnumeratorFunction
-                : IFunction<ReadOnlyCollectionWrapper<T>, Enumerator<T>>
-            {
-                public Enumerator<T> Invoke(ReadOnlyCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }  
     }
 }

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsReadOnlyList.cs

@@ -24,9 +24,6 @@ internal ReadOnlyListWrapper(T[] source)
 
             public T this[int index] 
                 => source[index];
-
-            public new ReadOnlyListExtensions.ValueEnumerable<ReadOnlyListWrapper<T>, T> AsValueEnumerable()
-                => this.AsValueEnumerable<ReadOnlyListWrapper<T>, T>();
         }
     }
 }

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueCollection.cs

@@ -51,18 +51,6 @@ bool ICollection<T>.Remove(T item)
                 => throw new NotSupportedException();
             void ICollection<T>.Clear() 
                 => throw new NotSupportedException();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyCollectionExtensions.ValueEnumerable<ValueCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyCollectionExtensions.AsValueEnumerable<ValueCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueCollectionWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }
     }
 }

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueEnumerable.cs

@@ -32,10 +32,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueEnumerableExtensions.ValueEnumerable<ValueEnumerableWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueEnumerableExtensions.AsValueEnumerable<ValueEnumerableWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
 
             public readonly struct GetEnumeratorFunction
                 : IFunction<ValueEnumerableWrapper<T>, Enumerator<T>>

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueList.cs

@@ -68,18 +68,6 @@ void IList<T>.Insert(int index, T item)
                 => throw new NotSupportedException();
             void IList<T>.RemoveAt(int index) 
                 => throw new NotSupportedException();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.ValueEnumerable<ValueListWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyListExtensions.AsValueEnumerable<ValueListWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueListWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueListWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }        
         }
     }
 }

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyCollection.cs

@@ -35,18 +35,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator()
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ReadOnlyCollectionExtensions.ValueEnumerable<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ReadOnlyCollectionExtensions.AsValueEnumerable<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueReadOnlyCollectionWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueReadOnlyCollectionWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }
         }
     }
 }

NetFabric.Hyperlinq.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs → NetFabric.Hyperlinq.Core.UnitTests/Utils/Wrappers/Wrap.AsValueReadOnlyList.cs

@@ -38,18 +38,6 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
             IEnumerator IEnumerable.GetEnumerator() 
                 // ReSharper disable once HeapView.BoxingAllocation
                 => GetEnumerator();
-
-            [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            public ValueReadOnlyListExtensions.ValueEnumerable<ValueReadOnlyListWrapper<T>, Enumerator<T>, Enumerator<T>, T, GetEnumeratorFunction, GetEnumeratorFunction> AsValueEnumerable()
-                => ValueReadOnlyListExtensions.AsValueEnumerable<ValueReadOnlyListWrapper<T>, Enumerator<T>, T, GetEnumeratorFunction>(this);
-
-            public readonly struct GetEnumeratorFunction
-                : IFunction<ValueReadOnlyListWrapper<T>, Enumerator<T>>
-            {
-                [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                public Enumerator<T> Invoke(ValueReadOnlyListWrapper<T> enumerable) 
-                    => enumerable.GetEnumerator();
-            }        
         }
     }
 }

NetFabric.Hyperlinq/Aggregation/Count/Count.ReadOnlySpan.cs → NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ReadOnlySpan.cs

@@ -6,14 +6,14 @@ namespace NetFabric.Hyperlinq
     public static partial class ArrayExtensions
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source)
+        public static int Count<TSource>(ReadOnlySpan<TSource> source)
             => source.Length;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
+        public static int Count<TSource>(ReadOnlySpan<TSource> source, Func<TSource, bool> predicate)
             => source.Count(new FunctionWrapper<TSource, bool>(predicate));
 
-        static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
+        public static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
             where TPredicate: struct, IFunction<TSource, bool>
         {
             var counter = 0;
@@ -25,10 +25,10 @@ static int Count<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredic
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, int, bool> predicate)
+        public static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource, int, bool> predicate)
             => source.CountAt(new FunctionWrapper<TSource, int, bool>(predicate));
 
-        static int CountAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
+        public static int CountAt<TSource, TPredicate>(this ReadOnlySpan<TSource> source, TPredicate predicate = default)
             where TPredicate: struct, IFunction<TSource, int, bool>
         {
             var counter = 0;

NetFabric.Hyperlinq/Aggregation/Count/Count.ValueEnumerable.cs → NetFabric.Hyperlinq.Core/Aggregation/Count/Count.ValueEnumerable.cs

@@ -20,12 +20,6 @@ public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable sour
             return counter;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.Count<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
-
         public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>
             where TEnumerator : struct, IEnumerator<TSource>
@@ -40,12 +34,6 @@ public static int Count<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnu
             }
             return counter;
         }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static int Count<TEnumerable, TEnumerator, TSource>(this TEnumerable source, Func<TSource, int, bool> predicate)
-            where TEnumerable : IValueEnumerable<TSource, TEnumerator>
-            where TEnumerator : struct, IEnumerator<TSource>
-            => source.CountAt<TEnumerable, TEnumerator, TSource, FunctionWrapper<TSource, int, bool>>(new FunctionWrapper<TSource, int, bool>(predicate));
 
         public static int CountAt<TEnumerable, TEnumerator, TSource, TPredicate>(this TEnumerable source, TPredicate predicate = default)
             where TEnumerable : IValueEnumerable<TSource, TEnumerator>