Update Ix.NET for .NET 8.0 sdk

Ix.NET/Source/.editorconfig

@@ -0,0 +1,34 @@
+[*.cs]
+
+# Prevent IDE1006 (Naming rule violation) errors for non-public fields.
+#
+# Unfortunately, the codebase has not historically been entirely consistent with internal naming
+# conventions. Apparently this wasn't noticed by older analyzer tooling, but as of the .NET 7
+# era, the naming rules analyzers are a bit more particular, and cannot be configured in a way
+# that makes them happy with the code as it stands. We could rename all the relevant symbols,
+# but that doesn't seem like an especially good use of time, so for now, we're suppressing
+# diagnostics in certain cases.
+#
+# Static readonly fields
+#dotnet_naming_rule.static_readonly_fields_should_be_pascal_case.severity = none
+
+# Internal fields
+dotnet_naming_symbols.internal_field_symbols.applicable_kinds           = field
+dotnet_naming_symbols.internal_field_symbols.applicable_accessibilities = internal
+
+dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.symbols  = internal_field_symbols
+dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.style    = camel_case_and_prefix_with_underscore_style
+#dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.severity = none
+
+
+# Protected fields
+# Annoyingly, a protected field in an internal class cannot be distinguished from a protected field in a public
+# class. That's unfortunate, because the latter are publicly visible, but the former are not, so we don't really
+# want to enforce public naming conventions on them. We generally avoid publicly visible fields, so the majority
+# of protected fields are in fact in internal types, so we use naming conventions appropriate to those.
+dotnet_naming_symbols.protected_field_symbols.applicable_kinds           = field
+dotnet_naming_symbols.protected_field_symbols.applicable_accessibilities = protected
+
+dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.symbols  = protected_field_symbols
+dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.style    = camel_case_and_prefix_with_underscore_style
+dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.severity = none

Ix.NET/Source/ApiCompare/ApiCompare.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

Ix.NET/Source/AsyncQueryableGenerator.t4

@@ -1,43 +1,84 @@
 <#@ assembly name="System.Core" #>
 <#@ assembly name="System.Runtime" #>
 <#@ import namespace="System.Linq" #>
+<#@ import namespace="System.Reflection" #>
 <#@ import namespace="System.Text" #>
 <#@ import namespace="System.Threading" #>
 <#@ import namespace="System.Threading.Tasks" #>
 <#@ import namespace="System.Collections.Generic" #>
 <#
 var infoFieldNames = new Dictionary<string, int>();
 
-var toQuotedImpl = default(Func<Type, int, bool, string>);
-toQuotedImpl = (t, i, b) =>
+var toQuotedImpl = default(Func<Type, ParameterInfo, int, bool, string>);
+toQuotedImpl = (t, paramObjectForAttributes, parameterIndex, notNestedGenericTypeParameter) =>
 {
 var name = t.Name;
 
+// We always want to look at the whole-type nullability, so we look at that now, and if it's a generic
+// type, we'll also go on to inspect per-type-parameter nullability.
+var nullableData = paramObjectForAttributes?.GetCustomAttributesData().SingleOrDefault(ad => ad.AttributeType.FullName == "System.Runtime.CompilerServices.NullableAttribute");
+bool wholeTypeNullable = false;
+if (nullableData is not null)
+{
+    if (nullableData.ConstructorArguments[0].Value is IReadOnlyList<CustomAttributeTypedArgument> nullableFlags)
+    {
+        // When we end up in this part, the type argument is, in practice, being used as the type argument to
+        // the actual type. E.g., ValueTask<TSource?>. So we need to look at the second nullable flag.
+        wholeTypeNullable = ((byte)nullableFlags[1].Value) == 2;
+    }
+    else if (nullableData.ConstructorArguments[0].Value is byte bv)
+    {
+        wholeTypeNullable = bv == 2;
+    }
+}
 if (t.IsGenericType)
 {
     var genDef = t.GetGenericTypeDefinition();
     name = genDef.Name.Substring(0, genDef.Name.LastIndexOf('`'));
 
-    var genArgs = "<" + string.Join(", ", t.GetGenericArguments().Select(a => toQuotedImpl(a, i, false))) + ">";
+    Type[] genericArguments = t.GetGenericArguments();
+    bool[] typeParamsNullable = new bool[genericArguments.Length];
+    if (nullableData is not null)
+    {
+        if (nullableData.ConstructorArguments[0].Value is IReadOnlyList<CustomAttributeTypedArgument> nullableFlags)
+        {
+            // There isn't a 1-1 correspondence between type parameters and nullable flags. Really we should be recursively
+            // walking the type parameters, but this hack suffices for the types we actually encounter in practice.
+            int flagIndex = 1;
+            for (int i = 0; i < typeParamsNullable.Length; ++i)
+            {
+                if (!genericArguments[i].IsValueType)
+                {
+                    if (flagIndex >= nullableFlags.Count) throw new InvalidOperationException($"Type {t} has {typeParamsNullable.Length} type params, but the associated nullable attribute on parameterinto {paramObjectForAttributes} has length {nullableFlags.Count}");
+                    typeParamsNullable[i] = ((byte)nullableFlags[flagIndex].Value) == 2;
+                    flagIndex += 1;
+                }
+            }
+        }
+    }
+
+    var genArgs = "<" + string.Join(", ", genericArguments.Select((a, i) => toQuotedImpl(a, null, parameterIndex, false) + (typeParamsNullable[i] ? "?" : ""))) + ">";
 
-    if (b)
+    if (notNestedGenericTypeParameter)
     {
         if (name == "Func" || name == "Action")
         {
             name = "Expression<" + name + genArgs + ">";
         }
-        else if (name == "IAsyncEnumerable" && i == 0)
+        else if (name == "IAsyncEnumerable" && parameterIndex == 0)
         {
             name = "IAsyncQueryable" + genArgs;
         }
-        else if (name == "IOrderedAsyncEnumerable" && i == 0)
+        else if (name == "IOrderedAsyncEnumerable" && parameterIndex == 0)
         {
             name = "IOrderedAsyncQueryable" + genArgs;
         }
         else
         {
             name += genArgs;
         }
+
+        //if (wholeTypeNullable) { name += "?"; }
     }
     else
     {
@@ -48,12 +89,13 @@ if (t.IsGenericType)
         else
         {
             name += genArgs;
+            if (wholeTypeNullable) { name += "?"; }
         }
     }
 }
 else if (t.IsArray)
 {
-    var elem = toQuotedImpl(t.GetElementType(), i, b);
+    var elem = toQuotedImpl(t.GetElementType(), null, parameterIndex, notNestedGenericTypeParameter);
     name = elem + "[]";
 }
 else
@@ -86,12 +128,13 @@ else
     {
         name = "object";
     }
+    if (wholeTypeNullable) { name += "?"; }
 }
 
 return name;
 };
 
-var toQuoted = new Func<Type, int, string>((t, i) => toQuotedImpl(t, i, true));
+var toQuoted = new Func<Type, ParameterInfo, int, string>((t, paramObjectForAttributes, parameterIndex) => toQuotedImpl(t, paramObjectForAttributes, parameterIndex, true));
 #>
 #nullable enable
 
@@ -125,16 +168,16 @@ foreach (var m in asyncEnumerableType.GetMethods()
                         .OrderBy(m => m.Name)
                         .ThenBy(m => m.IsGenericMethod ? m.GetGenericArguments().Length : 0)
                         .ThenBy(m => m.GetParameters().Length)
-                        .ThenBy(m => string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, i) + " " + p.Name))))
+                        .ThenBy(m => string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, p, i) + " " + p.Name))))
 {
     var genArgs = m.GetGenericArguments();
 
-    var ret = toQuoted(m.ReturnType, 0);
+    var ret = toQuoted(m.ReturnType, m.ReturnParameter, 0);
     var name = m.Name;
 
     if (genArgs.Length > 0)
     {
-        name += "<" + string.Join(", ", genArgs.Select(a => a.Name)) + ">";
+        name += "<" + string.Join(", ", genArgs.Select((a, i) => a.Name)) + ">";
     }
 
     var isParams = false;
@@ -156,8 +199,8 @@ foreach (var m in asyncEnumerableType.GetMethods()
         }
     }
 
-    var pars = string.Join(", ", m.GetParameters().Select((p, i) => (i == parCount - 1 && isParams ? "params " : "") + toQuoted(p.ParameterType, i) + (nullableParameterNames.Contains(p.Name) ? "?" : "") + " " + p.Name + (i == parCount - 1 && lastParameterDefault ? " = default" : "")));
-    var quotedPars = string.Join(", ", m.GetParameters().Select((p, i) => "default(" + toQuoted(p.ParameterType, i) + ")"));
+    var pars = string.Join(", ", m.GetParameters().Select((p, i) => (i == parCount - 1 && isParams ? "params " : "") + toQuoted(p.ParameterType, p, i) + (nullableParameterNames.Contains(p.Name) ? "?" : "") + " " + p.Name + (i == parCount - 1 && lastParameterDefault ? " = default" : "")));
+    var quotedPars = string.Join(", ", m.GetParameters().Select((p, i) => "default(" + toQuoted(p.ParameterType, p, i) + ")"));
 
     if (m.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), true))
     {
@@ -193,7 +236,7 @@ foreach (var m in asyncEnumerableType.GetMethods()
 
     infoName += infoNameId;
 
-    var infoSignature = string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, i)).Concat(new[] { toQuoted(m.ReturnType, 0) }));
+    var infoSignature = string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, p, i)).Concat(new[] { toQuoted(m.ReturnType, m.ReturnParameter, 0) }));
 
     foreach (var genArg in genArgs)
     {
@@ -219,7 +262,7 @@ foreach (var m in asyncEnumerableType.GetMethods()
 
         if (td.Name.EndsWith("Task`1")) // NB: Covers Task and ValueTask
         {
-            factory = "ExecuteAsync<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], -1, false) + ">";
+            factory = "ExecuteAsync<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], m.ReturnParameter, -1, false) + ">";
 
             var last = m.GetParameters().Last();
             if (last.ParameterType == typeof(CancellationToken))
@@ -233,11 +276,11 @@ foreach (var m in asyncEnumerableType.GetMethods()
         }
         else if (td == typeof(IAsyncEnumerable<>) || td == typeof(IOrderedAsyncEnumerable<>))
         {
-            factory = "CreateQuery<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], -1, false) + ">";
+            factory = "CreateQuery<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], null, -1, false) + ">";
 
             if (td == typeof(IOrderedAsyncEnumerable<>))
             {
-                cast = "(" + toQuoted(m.ReturnType, 0) + ")";
+                cast = "(" + toQuoted(m.ReturnType, null, 0) + ")";
             }
         }
     }
@@ -274,7 +317,7 @@ foreach (var m in asyncEnumerableType.GetMethods()
 
         if (!add)
         {
-            quotedArgs.Add("Expression.Constant(" + p.Name + ", typeof(" + toQuoted(pt, -1) + "))");
+            quotedArgs.Add("Expression.Constant(" + p.Name + ", typeof(" + toQuoted(pt, null, -1) + "))");
         }
 
         n++;

Ix.NET/Source/Directory.Build.props

@@ -10,7 +10,11 @@
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>$(MSBuildThisFileDirectory)ReactiveX.snk</AssemblyOriginatorKeyFile>
-    <NoWarn>$(NoWarn);1701;1702;CS1591;NU5105</NoWarn>
+    <!--
+    IDE0056 Suggests using range-based indexing, which doesn't work on .NET 4.8 (even in cases where it would compile down to code with no dependency on Index or Range).
+    IDE0270 Null check can be simplified. Tends to suggest using for exception throwing cases even when the resulting code would be overly complex.
+    -->
+    <NoWarn>$(NoWarn);1701;1702;CS1591;NU5105;IDE0056;IDE0270</NoWarn>
     <DefaultLanguage>en-US</DefaultLanguage>
     <IsTestProject>$(MSBuildProjectName.Contains('Test'))</IsTestProject>
     <EmbedUntrackedSources>true</EmbedUntrackedSources>

Ix.NET/Source/Playground/DemoAttribute.cs

@@ -7,15 +7,9 @@
 namespace Playground
 {
     [AttributeUsage(AttributeTargets.Method)]
-    internal sealed class DemoAttribute : Attribute
+    internal sealed class DemoAttribute(int index, string title) : Attribute
     {
-        public DemoAttribute(int index, string title)
-        {
-            Index = index;
-            Title = title;
-        }
-
-        public int Index { get; }
-        public string Title { get; }
+        public int Index { get; } = index;
+        public string Title { get; } = title;
     }
 }

Ix.NET/Source/Playground/Playground.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

Ix.NET/Source/Playground/Program.cs

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
+#pragma warning disable IDE0051 // Remove unused private members - all used via reflection
+
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -10,22 +12,22 @@
 
 namespace Playground
 {
-    class Program
+    internal class Program
     {
-        static void Main()
+        private static void Main()
         {
             RunDemos();
         }
 
         [Demo(0, "Random experimentation")]
-        static async Task Experiment()
+        private static async Task Experiment()
         {
             // Add test code here
             await Task.Yield(); // Suppress CS1998
         }
 
         [Demo(11, "LINQ to Objects for IEnumerable<T>")]
-        static void Linq()
+        private static void Linq()
         {
             var xs = new List<int> { 1, 2, 3 };
             var ys = xs.Where(x => x % 2 == 0);
@@ -37,7 +39,7 @@ static void Linq()
         }
 
         [Demo(12, "LINQ to Objects for IQueryable<T>")]
-        static void LinqQueryable()
+        private static void LinqQueryable()
         {
             var xs = new List<int> { 1, 2, 3 }.AsQueryable();
             var ys = xs.Where(x => x % 2 == 0);
@@ -49,7 +51,7 @@ static void LinqQueryable()
         }
 
         [Demo(21, "LINQ to Objects for IEnumerable<T> - Interactive Extensions")]
-        static void Ix()
+        private static void Ix()
         {
             var xs = new List<int> { 1, 2, 3 };
             var ys = xs.Distinct(x => x % 2);
@@ -61,7 +63,7 @@ static void Ix()
         }
 
         [Demo(22, "LINQ to Objects for IQueryable<T> - Interactive Extensions")]
-        static void IxQueryable()
+        private static void IxQueryable()
         {
             var xs = new List<int> { 1, 2, 3 }.AsQueryable();
             var ys = xs.Distinct(x => x % 2);
@@ -73,7 +75,7 @@ static void IxQueryable()
         }
 
         [Demo(31, "LINQ to Objects for IAsyncEnumerable<T>")]
-        static async Task AsyncLinq()
+        private static async Task AsyncLinq()
         {
             var xs = new List<int> { 1, 2, 3 };
             var ys = xs.ToAsyncEnumerable().Where(x => x % 2 == 0);
@@ -103,7 +105,7 @@ static async Task AsyncLinq()
         }
 
         [Demo(32, "LINQ to Objects for IAsyncQueryable<T>")]
-        static async Task AsyncLinqQueryable()
+        private static async Task AsyncLinqQueryable()
         {
             var xs = new List<int> { 1, 2, 3 }.AsQueryable();
             var ys = xs.ToAsyncEnumerable().Where(x => x % 2 == 0);
@@ -133,7 +135,7 @@ static async Task AsyncLinqQueryable()
         }
 
         [Demo(41, "LINQ to Objects for IAsyncEnumerable<T> - Interactive Extensions")]
-        static async Task AsyncIx()
+        private static async Task AsyncIx()
         {
             var xs = new List<int> { 1, 2, 3 };
             var ys = xs.ToAsyncEnumerable().Distinct(x => x % 2);
@@ -152,7 +154,7 @@ await ys.ForEachAsync(y =>
         }
 
         [Demo(42, "LINQ to Objects for IAsyncQueryable<T> - Interactive Extensions")]
-        static async Task AsyncIxQueryable()
+        private static async Task AsyncIxQueryable()
         {
             var xs = new List<int> { 1, 2, 3 }.AsQueryable();
             var ys = xs.ToAsyncEnumerable().Distinct(x => x % 2);
@@ -170,7 +172,7 @@ await ys.ForEachAsync(y =>
 #endif
         }
 
-        static void RunDemos()
+        private static void RunDemos()
         {
             var methods = (from method in typeof(Program).GetTypeInfo().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static)
                            let demo = method.GetCustomAttribute<DemoAttribute>()
@@ -197,7 +199,7 @@ orderby demo.Index
                 while (retry)
                 {
                     Console.Write("Enter demo [C: Clear, X: Exit]: ");
-                    var input = Console.ReadLine().Trim().ToUpper();
+                    var input = Console.ReadLine()?.Trim().ToUpper();
 
                     switch (input)
                     {