chore: Enable nullable annotation for validators (#2902)

filzrev · web-flow · commit 6b77c83dc5df · 2025-12-08T16:05:31.000-05:00
* chore: enable nullable for validators

* chore: fix code based on review comment

* chore: fix code based on review comment
diff --git a/src/BenchmarkDotNet/Validators/BaselineValidator.cs b/src/BenchmarkDotNet/Validators/BaselineValidator.cs
@@ -1,7 +1,10 @@
-﻿using System.Collections.Generic;
+﻿using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Order;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using BenchmarkDotNet.Jobs;
+
+#nullable enable
 
 namespace BenchmarkDotNet.Validators
 {
@@ -16,14 +19,14 @@ private BaselineValidator() { }
         public IEnumerable<ValidationError> Validate(ValidationParameters input)
         {
             var allBenchmarks = input.Benchmarks.ToImmutableArray();
-            var orderProvider = input.Config.Orderer;
+            var orderProvider = input.Config.Orderer ?? DefaultOrderer.Instance;
 
             var benchmarkLogicalGroups = allBenchmarks
                 .Select(benchmark => orderProvider.GetLogicalGroupKey(allBenchmarks, benchmark))
                 .ToArray();
 
             var logicalGroups = benchmarkLogicalGroups.Distinct().ToArray();
-            foreach (string logicalGroup in logicalGroups)
+            foreach (string? logicalGroup in logicalGroups)
             {
                 var benchmarks = allBenchmarks.Where((benchmark, index) => benchmarkLogicalGroups[index] == logicalGroup).ToArray();
                 int methodBaselineCount = benchmarks.Select(b => b.Descriptor).Distinct().Count(it => it.Baseline);
@@ -38,7 +41,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters input)
             }
         }
 
-        private ValidationError CreateError(string subject, string property, string groupName, string className, string actual) =>
+        private ValidationError CreateError(string subject, string property, string? groupName, string className, string actual) =>
             new ValidationError(
                 TreatsWarningsAsErrors,
                 $"Only 1 {subject} in a group can have \"{property}\" applied to it, group {groupName} in class {className} has {actual}");
diff --git a/src/BenchmarkDotNet/Validators/CompilationValidator.cs b/src/BenchmarkDotNet/Validators/CompilationValidator.cs
@@ -9,6 +9,8 @@
 using Microsoft.CodeAnalysis.CSharp;
 using BenchmarkDotNet.Attributes;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class CompilationValidator : IValidator
@@ -133,7 +135,7 @@ private class BenchmarkMethodEqualityComparer : IEqualityComparer<BenchmarkCase>
         {
             internal static readonly IEqualityComparer<BenchmarkCase> Instance = new BenchmarkMethodEqualityComparer();
 
-            public bool Equals(BenchmarkCase x, BenchmarkCase y)
+            public bool Equals(BenchmarkCase? x, BenchmarkCase? y)
             {
                 if (x == null && y == null) return true;
                 if (x == null || y == null) return false;
diff --git a/src/BenchmarkDotNet/Validators/ConfigValidator.cs b/src/BenchmarkDotNet/Validators/ConfigValidator.cs
@@ -6,6 +6,8 @@
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Loggers;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class ConfigValidator : IValidator
@@ -38,7 +40,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
                 yield return pathValidation;
         }
 
-        private static ValidationError ValidateArtifactsPath(string artifactsPath)
+        private static ValidationError? ValidateArtifactsPath(string artifactsPath)
         {
             if (artifactsPath == null) // null is OK, default path will be used
                 return null;
diff --git a/src/BenchmarkDotNet/Validators/DeferredExecutionValidator.cs b/src/BenchmarkDotNet/Validators/DeferredExecutionValidator.cs
@@ -5,6 +5,8 @@
 using System.Threading.Tasks;
 using BenchmarkDotNet.Extensions;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class DeferredExecutionValidator : IValidator
@@ -29,7 +31,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
         private bool IsDeferredExecution(Type returnType)
         {
             if (returnType.IsByRef && !returnType.IsGenericType)
-                return IsDeferredExecution(returnType.GetElementType());
+                return IsDeferredExecution(returnType.GetElementType()!);
 
             if (returnType.IsGenericType && (returnType.GetGenericTypeDefinition() == typeof(Task<>) || returnType.GetGenericTypeDefinition() == typeof(ValueTask<>)))
                 return IsDeferredExecution(returnType.GetGenericArguments().Single());
diff --git a/src/BenchmarkDotNet/Validators/DotNetSdkValidator.cs b/src/BenchmarkDotNet/Validators/DotNetSdkValidator.cs
@@ -6,10 +6,13 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     internal static class DotNetSdkValidator
@@ -26,15 +29,15 @@ public static IEnumerable<ValidationError> ValidateCoreSdks(string? customDotNet
             var requiredSdkVersion = benchmark.GetRuntime().RuntimeMoniker.GetRuntimeVersion();
             if (!GetInstalledDotNetSdks(customDotNetCliPath).Any(sdk => sdk >= requiredSdkVersion))
             {
-                yield return new ValidationError(true, $"The required .NET Core SDK version {requiredSdkVersion} or higher for runtime moniker {benchmark.Job.Environment.Runtime.RuntimeMoniker} is not installed.", benchmark);
+                yield return new ValidationError(true, $"The required .NET Core SDK version {requiredSdkVersion} or higher for runtime moniker {benchmark.Job.Environment.Runtime!.RuntimeMoniker} is not installed.", benchmark);
             }
         }
 
         public static IEnumerable<ValidationError> ValidateFrameworkSdks(BenchmarkCase benchmark)
         {
             var targetRuntime = benchmark.Job.Environment.HasValue(EnvironmentMode.RuntimeCharacteristic)
-                ? benchmark.Job.Environment.Runtime
-                : ClrRuntime.GetTargetOrCurrentVersion(benchmark.Descriptor.WorkloadMethod.DeclaringType.Assembly);
+                ? benchmark.Job.Environment.Runtime!
+                : ClrRuntime.GetTargetOrCurrentVersion(benchmark.Descriptor.WorkloadMethod.DeclaringType!.Assembly);
             var requiredSdkVersion = targetRuntime.RuntimeMoniker.GetRuntimeVersion();
 
             var installedVersionString = cachedFrameworkSdks.Value.FirstOrDefault();
@@ -44,7 +47,7 @@ public static IEnumerable<ValidationError> ValidateFrameworkSdks(BenchmarkCase b
             }
         }
 
-        public static bool IsCliPathInvalid(string customDotNetCliPath, BenchmarkCase benchmarkCase, out ValidationError? validationError)
+        public static bool IsCliPathInvalid(string? customDotNetCliPath, BenchmarkCase benchmarkCase, [NotNullWhen(true)] out ValidationError? validationError)
         {
             validationError = null;
 
@@ -71,7 +74,7 @@ public static bool IsCliPathInvalid(string customDotNetCliPath, BenchmarkCase be
 
         private static IEnumerable<Version> GetInstalledDotNetSdks(string? customDotNetCliPath)
         {
-            string dotnetExecutable = string.IsNullOrEmpty(customDotNetCliPath) ? "dotnet" : customDotNetCliPath;
+            string dotnetExecutable = string.IsNullOrEmpty(customDotNetCliPath) ? "dotnet" : customDotNetCliPath!;
             var startInfo = new ProcessStartInfo(dotnetExecutable, "--list-sdks")
             {
                 RedirectStandardOutput = true,
@@ -146,13 +149,13 @@ private static void Get45PlusFromRegistry(List<string> versions)
 
                 if (ndpKey.GetValue("Version") != null)
                 {
-                    versions.Add(ndpKey.GetValue("Version").ToString());
+                    versions.Add(ndpKey.GetValue("Version")!.ToString()!);
                 }
                 else
                 {
                     if (ndpKey.GetValue("Release") != null)
                     {
-                        versions.Add(CheckFor45PlusVersion((int)ndpKey.GetValue("Release")));
+                        versions.Add(CheckFor45PlusVersion((int)ndpKey.GetValue("Release")!));
                     }
                 }
             }
diff --git a/src/BenchmarkDotNet/Validators/ExecutionValidatorBase.cs b/src/BenchmarkDotNet/Validators/ExecutionValidatorBase.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
@@ -8,6 +9,8 @@
 using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Running;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public abstract class ExecutionValidatorBase : IValidator
@@ -53,11 +56,11 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
             return errors;
         }
 
-        private bool TryCreateBenchmarkTypeInstance(Type type, List<ValidationError> errors, out object? instance)
+        private bool TryCreateBenchmarkTypeInstance(Type type, List<ValidationError> errors, [NotNullWhen(true)] out object? instance)
         {
             try
             {
-                instance = Activator.CreateInstance(type);
+                instance = Activator.CreateInstance(type)!;
 
                 return true;
             }
@@ -124,7 +127,7 @@ private bool TryToCallGlobalMethod<T>(object benchmarkTypeInstance, List<Validat
 
         private string GetAttributeName(Type type) => type.Name.Replace("Attribute", string.Empty);
 
-        private void TryToGetTaskResult(object result)
+        private void TryToGetTaskResult(object? result)
         {
             if (result == null)
             {
@@ -241,7 +244,7 @@ private bool TryToSetParamsProperties(object benchmarkTypeInstance, List<Validat
         protected static string GetDisplayExceptionMessage(Exception ex)
         {
             if (ex is TargetInvocationException targetInvocationException)
-                ex = targetInvocationException.InnerException;
+                ex = targetInvocationException.InnerException!;
 
             return ex?.Message ?? "Unknown error";
         }
diff --git a/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs b/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs
@@ -1,10 +1,13 @@
 ﻿using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Extensions;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class ParamsAllValuesValidator : IValidator
@@ -24,7 +27,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters input) =>
                 .SelectMany(type => type.GetTypeMembersWithGivenAttribute<ParamsAllValuesAttribute>(ReflectionFlags))
                 .Distinct()
                 .Select(member => GetErrorOrDefault(member.ParameterType))
-                .Where(error => error != null);
+                .WhereNotNull();
 
         private bool IsBool(Type paramType) => paramType == typeof(bool);
         private bool IsEnum(Type paramType) => paramType.GetTypeInfo().IsEnum;
@@ -33,17 +36,17 @@ private bool IsFlagsEnum(Type paramType)
             var typeInfo = paramType.GetTypeInfo();
             return typeInfo.IsEnum && typeInfo.IsDefined(typeof(FlagsAttribute));
         }
-        private bool IsNullable(Type paramType, out Type underlyingType)
+        private bool IsNullable(Type paramType, [NotNullWhen(true)] out Type? underlyingType)
         {
             underlyingType = Nullable.GetUnderlyingType(paramType);
             return underlyingType != null;
         }
 
-        private ValidationError GetErrorOrDefault(Type parameterType)
+        private ValidationError? GetErrorOrDefault(Type parameterType)
         {
             switch (parameterType)
             {
-                case Type t when IsNullable(t, out Type underType):
+                case Type t when IsNullable(t, out var underType):
                     return GetErrorOrDefault(underType);
 
                 case Type t when IsFlagsEnum(t):
diff --git a/src/BenchmarkDotNet/Validators/ReturnValueValidator.cs b/src/BenchmarkDotNet/Validators/ReturnValueValidator.cs
@@ -10,6 +10,8 @@
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Toolchains.InProcess.NoEmit;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class ReturnValueValidator : ExecutionValidatorBase
@@ -32,7 +34,7 @@ protected override void ExecuteBenchmarks(object benchmarkTypeInstance, IEnumera
                     try
                     {
                         InProcessNoEmitRunner.FillMembers(benchmarkTypeInstance, benchmark);
-                        var result = benchmark.Descriptor.WorkloadMethod.Invoke(benchmarkTypeInstance, null);
+                        var result = benchmark.Descriptor.WorkloadMethod.Invoke(benchmarkTypeInstance, null)!;
 
                         if (benchmark.Descriptor.WorkloadMethod.ReturnType != typeof(void))
                             results.Add((benchmark, result));
@@ -64,7 +66,7 @@ private class ParameterInstancesEqualityComparer : IEqualityComparer<ParameterIn
         {
             public static ParameterInstancesEqualityComparer Instance { get; } = new ParameterInstancesEqualityComparer();
 
-            public bool Equals(ParameterInstances x, ParameterInstances y)
+            public bool Equals(ParameterInstances? x, ParameterInstances? y)
             {
                 if (ReferenceEquals(x, y))
                     return true;
@@ -98,7 +100,7 @@ private class InDepthEqualityComparer : IEqualityComparer
             public static InDepthEqualityComparer Instance { get; } = new InDepthEqualityComparer();
 
             [SuppressMessage("ReSharper", "MemberHidesStaticFromOuterClass")]
-            public new bool Equals(object x, object y)
+            public new bool Equals(object? x, object? y)
             {
                 if (ReferenceEquals(x, y) || object.Equals(x, y))
                     return true;
@@ -137,7 +139,7 @@ private bool CompareStructural(object x, object y)
 
                 return false;
 
-                Array ToStructuralEquatable(object obj)
+                Array? ToStructuralEquatable(object obj)
                 {
                     switch (obj)
                     {
diff --git a/src/BenchmarkDotNet/Validators/ValidationError.cs b/src/BenchmarkDotNet/Validators/ValidationError.cs
@@ -2,6 +2,8 @@
 using BenchmarkDotNet.Running;
 using JetBrains.Annotations;
 
+#nullable enable
+
 namespace BenchmarkDotNet.Validators
 {
     public class ValidationError : IEquatable<ValidationError>
@@ -43,6 +45,6 @@ public override bool Equals(object? obj)
 
         public static bool operator ==(ValidationError left, ValidationError right) => Equals(left, right);
 
-        public static bool operator !=(ValidationError left, ValidationError right) => !Equals(left, right);
+        public static bool operator !=(ValidationError? left, ValidationError? right) => !Equals(left, right);
     }
 }
diff --git a/src/BenchmarkDotNet/Validators/ValidationParameters.cs b/src/BenchmarkDotNet/Validators/ValidationParameters.cs
@@ -10,16 +10,16 @@ public class ValidationParameters
     {
         public IReadOnlyList<BenchmarkCase> Benchmarks { get; }
 
-        public ImmutableConfig? Config { get; }
+        public ImmutableConfig Config { get; }
 
-        public ValidationParameters(IReadOnlyList<BenchmarkCase> benchmarks, ImmutableConfig? config)
+        public ValidationParameters(IReadOnlyList<BenchmarkCase> benchmarks, ImmutableConfig config)
         {
             Benchmarks = benchmarks;
             Config = config;
         }
 
-        // to have backward compatibility for people who implemented IValidator(Benchmark[] benchmarks)
-        public static implicit operator ValidationParameters(BenchmarkCase[] benchmarksCase) => new ValidationParameters(benchmarksCase, null);
-        public static implicit operator ValidationParameters(BenchmarkRunInfo benchmarkRunInfo) => new ValidationParameters(benchmarkRunInfo.BenchmarksCases, null);
+        // Note: Following implicit operators are expected to be used for test projects.
+        public static implicit operator ValidationParameters(BenchmarkCase[] benchmarksCase) => new ValidationParameters(benchmarksCase, DefaultConfig.Instance.CreateImmutableConfig());
+        public static implicit operator ValidationParameters(BenchmarkRunInfo benchmarkRunInfo) => new ValidationParameters(benchmarkRunInfo.BenchmarksCases, benchmarkRunInfo.Config);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`using Microsoft.CodeAnalysis.CSharp;`
`10`	`10`	`using BenchmarkDotNet.Attributes;`
`11`	`11`
	`12`	`+#nullable enable`
	`13`	`+`
`12`	`14`	`namespace BenchmarkDotNet.Validators`
`13`	`15`	`{`
`14`	`16`	`public class CompilationValidator : IValidator`
`@@ -133,7 +135,7 @@ private class BenchmarkMethodEqualityComparer : IEqualityComparer<BenchmarkCase>`
`133`	`135`	`{`
`134`	`136`	`internal static readonly IEqualityComparer<BenchmarkCase> Instance = new BenchmarkMethodEqualityComparer();`
`135`	`137`
`136`		`- public bool Equals(BenchmarkCase x, BenchmarkCase y)`
	`138`	`+ public bool Equals(BenchmarkCase? x, BenchmarkCase? y)`
`137`	`139`	`{`
`138`	`140`	`if (x == null && y == null) return true;`
`139`	`141`	`if (x == null \|\| y == null) return false;`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,8 @@`
`6`	`6`	`using BenchmarkDotNet.Extensions;`
`7`	`7`	`using BenchmarkDotNet.Loggers;`
`8`	`8`
	`9`	`+#nullable enable`
	`10`	`+`
`9`	`11`	`namespace BenchmarkDotNet.Validators`
`10`	`12`	`{`
`11`	`13`	`public class ConfigValidator : IValidator`
`@@ -38,7 +40,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara`
`38`	`40`	`yield return pathValidation;`
`39`	`41`	`}`
`40`	`42`
`41`		`- private static ValidationError ValidateArtifactsPath(string artifactsPath)`
	`43`	`+ private static ValidationError? ValidateArtifactsPath(string artifactsPath)`
`42`	`44`	`{`
`43`	`45`	`if (artifactsPath == null) // null is OK, default path will be used`
`44`	`46`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -6,10 +6,13 @@`
`6`	`6`	`using System.Collections.Generic;`
`7`	`7`	`using System.ComponentModel;`
`8`	`8`	`using System.Diagnostics;`
	`9`	`+using System.Diagnostics.CodeAnalysis;`
`9`	`10`	`using System.IO;`
`10`	`11`	`using System.Linq;`
`11`	`12`	`using System.Runtime.InteropServices;`
`12`	`13`
	`14`	`+#nullable enable`
	`15`	`+`
`13`	`16`	`namespace BenchmarkDotNet.Validators`
`14`	`17`	`{`
`15`	`18`	`internal static class DotNetSdkValidator`
`@@ -26,15 +29,15 @@ public static IEnumerable<ValidationError> ValidateCoreSdks(string? customDotNet`
`26`	`29`	`var requiredSdkVersion = benchmark.GetRuntime().RuntimeMoniker.GetRuntimeVersion();`
`27`	`30`	`if (!GetInstalledDotNetSdks(customDotNetCliPath).Any(sdk => sdk >= requiredSdkVersion))`
`28`	`31`	`{`
`29`		`- yield return new ValidationError(true, $"The required .NET Core SDK version {requiredSdkVersion} or higher for runtime moniker {benchmark.Job.Environment.Runtime.RuntimeMoniker} is not installed.", benchmark);`
	`32`	`+ yield return new ValidationError(true, $"The required .NET Core SDK version {requiredSdkVersion} or higher for runtime moniker {benchmark.Job.Environment.Runtime!.RuntimeMoniker} is not installed.", benchmark);`
`30`	`33`	`}`
`31`	`34`	`}`
`32`	`35`
`33`	`36`	`public static IEnumerable<ValidationError> ValidateFrameworkSdks(BenchmarkCase benchmark)`
`34`	`37`	`{`
`35`	`38`	`var targetRuntime = benchmark.Job.Environment.HasValue(EnvironmentMode.RuntimeCharacteristic)`
`36`		`- ? benchmark.Job.Environment.Runtime`
`37`		`- : ClrRuntime.GetTargetOrCurrentVersion(benchmark.Descriptor.WorkloadMethod.DeclaringType.Assembly);`
	`39`	`+ ? benchmark.Job.Environment.Runtime!`
	`40`	`+ : ClrRuntime.GetTargetOrCurrentVersion(benchmark.Descriptor.WorkloadMethod.DeclaringType!.Assembly);`
`38`	`41`	`var requiredSdkVersion = targetRuntime.RuntimeMoniker.GetRuntimeVersion();`
`39`	`42`
`40`	`43`	`var installedVersionString = cachedFrameworkSdks.Value.FirstOrDefault();`
`@@ -44,7 +47,7 @@ public static IEnumerable<ValidationError> ValidateFrameworkSdks(BenchmarkCase b`
`44`	`47`	`}`
`45`	`48`	`}`
`46`	`49`
`47`		`- public static bool IsCliPathInvalid(string customDotNetCliPath, BenchmarkCase benchmarkCase, out ValidationError? validationError)`
	`50`	`+ public static bool IsCliPathInvalid(string? customDotNetCliPath, BenchmarkCase benchmarkCase, [NotNullWhen(true)] out ValidationError? validationError)`
`48`	`51`	`{`
`49`	`52`	`validationError = null;`
`50`	`53`
`@@ -71,7 +74,7 @@ public static bool IsCliPathInvalid(string customDotNetCliPath, BenchmarkCase be`
`71`	`74`
`72`	`75`	`private static IEnumerable<Version> GetInstalledDotNetSdks(string? customDotNetCliPath)`
`73`	`76`	`{`
`74`		`- string dotnetExecutable = string.IsNullOrEmpty(customDotNetCliPath) ? "dotnet" : customDotNetCliPath;`
	`77`	`+ string dotnetExecutable = string.IsNullOrEmpty(customDotNetCliPath) ? "dotnet" : customDotNetCliPath!;`
`75`	`78`	`var startInfo = new ProcessStartInfo(dotnetExecutable, "--list-sdks")`
`76`	`79`	`{`
`77`	`80`	`RedirectStandardOutput = true,`
`@@ -146,13 +149,13 @@ private static void Get45PlusFromRegistry(List<string> versions)`
`146`	`149`
`147`	`150`	`if (ndpKey.GetValue("Version") != null)`
`148`	`151`	`{`
`149`		`- versions.Add(ndpKey.GetValue("Version").ToString());`
	`152`	`+ versions.Add(ndpKey.GetValue("Version")!.ToString()!);`
`150`	`153`	`}`
`151`	`154`	`else`
`152`	`155`	`{`
`153`	`156`	`if (ndpKey.GetValue("Release") != null)`
`154`	`157`	`{`
`155`		`- versions.Add(CheckFor45PlusVersion((int)ndpKey.GetValue("Release")));`
	`158`	`+ versions.Add(CheckFor45PlusVersion((int)ndpKey.GetValue("Release")!));`
`156`	`159`	`}`
`157`	`160`	`}`
`158`	`161`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
	`3`	`+using System.Diagnostics.CodeAnalysis;`
`3`	`4`	`using System.Linq;`
`4`	`5`	`using System.Reflection;`
`5`	`6`	`using System.Threading.Tasks;`
`@@ -8,6 +9,8 @@`
`8`	`9`	`using BenchmarkDotNet.Helpers;`
`9`	`10`	`using BenchmarkDotNet.Running;`
`10`	`11`
	`12`	`+#nullable enable`
	`13`	`+`
`11`	`14`	`namespace BenchmarkDotNet.Validators`
`12`	`15`	`{`
`13`	`16`	`public abstract class ExecutionValidatorBase : IValidator`
`@@ -53,11 +56,11 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara`
`53`	`56`	`return errors;`
`54`	`57`	`}`
`55`	`58`
`56`		`- private bool TryCreateBenchmarkTypeInstance(Type type, List<ValidationError> errors, out object? instance)`
	`59`	`+ private bool TryCreateBenchmarkTypeInstance(Type type, List<ValidationError> errors, [NotNullWhen(true)] out object? instance)`
`57`	`60`	`{`
`58`	`61`	`try`
`59`	`62`	`{`
`60`		`- instance = Activator.CreateInstance(type);`
	`63`	`+ instance = Activator.CreateInstance(type)!;`
`61`	`64`
`62`	`65`	`return true;`
`63`	`66`	`}`
`@@ -124,7 +127,7 @@ private bool TryToCallGlobalMethod<T>(object benchmarkTypeInstance, List<Validat`
`124`	`127`
`125`	`128`	`private string GetAttributeName(Type type) => type.Name.Replace("Attribute", string.Empty);`
`126`	`129`
`127`		`- private void TryToGetTaskResult(object result)`
	`130`	`+ private void TryToGetTaskResult(object? result)`
`128`	`131`	`{`
`129`	`132`	`if (result == null)`
`130`	`133`	`{`
`@@ -241,7 +244,7 @@ private bool TryToSetParamsProperties(object benchmarkTypeInstance, List<Validat`
`241`	`244`	`protected static string GetDisplayExceptionMessage(Exception ex)`
`242`	`245`	`{`
`243`	`246`	`if (ex is TargetInvocationException targetInvocationException)`
`244`		`- ex = targetInvocationException.InnerException;`
	`247`	`+ ex = targetInvocationException.InnerException!;`
`245`	`248`
`246`	`249`	`return ex?.Message ?? "Unknown error";`
`247`	`250`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@`
`10`	`10`	`using BenchmarkDotNet.Running;`
`11`	`11`	`using BenchmarkDotNet.Toolchains.InProcess.NoEmit;`
`12`	`12`
	`13`	`+#nullable enable`
	`14`	`+`
`13`	`15`	`namespace BenchmarkDotNet.Validators`
`14`	`16`	`{`
`15`	`17`	`public class ReturnValueValidator : ExecutionValidatorBase`
`@@ -32,7 +34,7 @@ protected override void ExecuteBenchmarks(object benchmarkTypeInstance, IEnumera`
`32`	`34`	`try`
`33`	`35`	`{`
`34`	`36`	`InProcessNoEmitRunner.FillMembers(benchmarkTypeInstance, benchmark);`
`35`		`- var result = benchmark.Descriptor.WorkloadMethod.Invoke(benchmarkTypeInstance, null);`
	`37`	`+ var result = benchmark.Descriptor.WorkloadMethod.Invoke(benchmarkTypeInstance, null)!;`
`36`	`38`
`37`	`39`	`if (benchmark.Descriptor.WorkloadMethod.ReturnType != typeof(void))`
`38`	`40`	`results.Add((benchmark, result));`
`@@ -64,7 +66,7 @@ private class ParameterInstancesEqualityComparer : IEqualityComparer<ParameterIn`
`64`	`66`	`{`
`65`	`67`	`public static ParameterInstancesEqualityComparer Instance { get; } = new ParameterInstancesEqualityComparer();`
`66`	`68`
`67`		`- public bool Equals(ParameterInstances x, ParameterInstances y)`
	`69`	`+ public bool Equals(ParameterInstances? x, ParameterInstances? y)`
`68`	`70`	`{`
`69`	`71`	`if (ReferenceEquals(x, y))`
`70`	`72`	`return true;`
`@@ -98,7 +100,7 @@ private class InDepthEqualityComparer : IEqualityComparer`
`98`	`100`	`public static InDepthEqualityComparer Instance { get; } = new InDepthEqualityComparer();`
`99`	`101`
`100`	`102`	`[SuppressMessage("ReSharper", "MemberHidesStaticFromOuterClass")]`
`101`		`- public new bool Equals(object x, object y)`
	`103`	`+ public new bool Equals(object? x, object? y)`
`102`	`104`	`{`
`103`	`105`	`if (ReferenceEquals(x, y) \|\| object.Equals(x, y))`
`104`	`106`	`return true;`
`@@ -137,7 +139,7 @@ private bool CompareStructural(object x, object y)`
`137`	`139`
`138`	`140`	`return false;`
`139`	`141`
`140`		`- Array ToStructuralEquatable(object obj)`
	`142`	`+ Array? ToStructuralEquatable(object obj)`
`141`	`143`	`{`
`142`	`144`	`switch (obj)`
`143`	`145`	`{`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,8 @@`
`2`	`2`	`using BenchmarkDotNet.Running;`
`3`	`3`	`using JetBrains.Annotations;`
`4`	`4`
	`5`	`+#nullable enable`
	`6`	`+`
`5`	`7`	`namespace BenchmarkDotNet.Validators`
`6`	`8`	`{`
`7`	`9`	`public class ValidationError : IEquatable<ValidationError>`
`@@ -43,6 +45,6 @@ public override bool Equals(object? obj)`
`43`	`45`
`44`	`46`	`public static bool operator ==(ValidationError left, ValidationError right) => Equals(left, right);`
`45`	`47`
`46`		`- public static bool operator !=(ValidationError left, ValidationError right) => !Equals(left, right);`
	`48`	`+ public static bool operator !=(ValidationError? left, ValidationError? right) => !Equals(left, right);`
`47`	`49`	`}`
`48`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,16 +10,16 @@ public class ValidationParameters`
`10`	`10`	`{`
`11`	`11`	`public IReadOnlyList<BenchmarkCase> Benchmarks { get; }`
`12`	`12`
`13`		`- public ImmutableConfig? Config { get; }`
	`13`	`+ public ImmutableConfig Config { get; }`
`14`	`14`
`15`		`- public ValidationParameters(IReadOnlyList<BenchmarkCase> benchmarks, ImmutableConfig? config)`
	`15`	`+ public ValidationParameters(IReadOnlyList<BenchmarkCase> benchmarks, ImmutableConfig config)`
`16`	`16`	`{`
`17`	`17`	`Benchmarks = benchmarks;`
`18`	`18`	`Config = config;`
`19`	`19`	`}`
`20`	`20`
`21`		`- // to have backward compatibility for people who implemented IValidator(Benchmark[] benchmarks)`
`22`		`- public static implicit operator ValidationParameters(BenchmarkCase[] benchmarksCase) => new ValidationParameters(benchmarksCase, null);`
`23`		`- public static implicit operator ValidationParameters(BenchmarkRunInfo benchmarkRunInfo) => new ValidationParameters(benchmarkRunInfo.BenchmarksCases, null);`
	`21`	`+ // Note: Following implicit operators are expected to be used for test projects.`
	`22`	`+ public static implicit operator ValidationParameters(BenchmarkCase[] benchmarksCase) => new ValidationParameters(benchmarksCase, DefaultConfig.Instance.CreateImmutableConfig());`
	`23`	`+ public static implicit operator ValidationParameters(BenchmarkRunInfo benchmarkRunInfo) => new ValidationParameters(benchmarkRunInfo.BenchmarksCases, benchmarkRunInfo.Config);`
`24`	`24`	`}`
`25`	`25`	`}`