Enable nullable references in Moq.csproj

src/Moq/ActionObserver.cs

@@ -27,14 +27,14 @@ namespace Moq
     /// </summary>
     sealed class ActionObserver : ExpressionReconstructor
     {
-        public override Expression<Action<T>> ReconstructExpression<T>(Action<T> action, object[] ctorArgs = null)
+        public override Expression<Action<T>> ReconstructExpression<T>(Action<T> action, object?[]? ctorArgs = null)
         {
             using (var matcherObserver = MatcherObserver.Activate())
             {
                 // Create the root recording proxy:
                 var root = (T)CreateProxy(typeof(T), ctorArgs, matcherObserver, out var rootRecorder);
 
-                Exception error = null;
+                Exception? error = null;
                 try
                 {
                     // Execute the delegate. The root recorder will automatically "mock" return values
@@ -61,7 +61,7 @@ public override Expression<Action<T>> ReconstructExpression<T>(Action<T> action,
                     var invocation = recorder.Invocation;
                     if (invocation != null)
                     {
-                        var resultType = invocation.Method.DeclaringType;
+                        var resultType = invocation.Method.DeclaringType!;
                         if (resultType.IsAssignableFrom(body.Type) == false)
                         {
                             if (AwaitableFactory.TryGet(body.Type) is { } awaitableHandler
@@ -128,7 +128,7 @@ Expression[] GetArgumentExpressions(Invocation invocation, Match[] matches)
                         // it will have left behind a `default(T)` argument, possibly coerced to the parameter type.
                         // Therefore, we attempt to reproduce such coercions using `Convert.ChangeType`:
                         Type defaultValueType = matches[matchIndex].RenderExpression.Type;
-                        object defaultValue = defaultValueType.GetDefaultValue();
+                        object? defaultValue = defaultValueType.GetDefaultValue();
                         try
                         {
                             defaultValue = Convert.ChangeType(defaultValue, parameterTypes[argumentIndex]);
@@ -178,7 +178,7 @@ Expression[] GetArgumentExpressions(Invocation invocation, Match[] matches)
                                 CultureInfo.CurrentCulture,
                                 Resources.MatcherAssignmentFailedDuringExpressionReconstruction,
                                 matches.Length,
-                                $"{invocation.Method.DeclaringType.GetFormattedName()}.{invocation.Method.Name}"));
+                                $"{invocation.Method.DeclaringType!.GetFormattedName()}.{invocation.Method.Name}"));
                     }
 
                     bool CanDistribute(int msi, int asi)
@@ -228,10 +228,10 @@ bool CanDistribute(int msi, int asi)
         }
 
         // Creates a proxy (way more light-weight than a `Mock<T>`!) with an invocation `Recorder` attached to it.
-        static IProxy CreateProxy(Type type, object[] ctorArgs, MatcherObserver matcherObserver, out Recorder recorder)
+        static IProxy CreateProxy(Type type, object?[]? ctorArgs, MatcherObserver matcherObserver, out Recorder recorder)
         {
             recorder = new Recorder(matcherObserver);
-            return (IProxy)ProxyFactory.Instance.CreateProxy(type, recorder, Type.EmptyTypes, ctorArgs ?? new object[0]);
+            return (IProxy)ProxyFactory.Instance.CreateProxy(type, recorder, Type.EmptyTypes, ctorArgs ?? new object?[0]);
 
         }
 
@@ -241,9 +241,9 @@ sealed class Recorder : IInterceptor
         {
             readonly MatcherObserver matcherObserver;
             int creationTimestamp;
-            Invocation invocation;
+            Invocation? invocation;
             int invocationTimestamp;
-            object returnValue;
+            object? returnValue;
 
             public Recorder(MatcherObserver matcherObserver)
             {
@@ -253,7 +253,7 @@ public Recorder(MatcherObserver matcherObserver)
                 this.creationTimestamp = this.matcherObserver.GetNextTimestamp();
             }
 
-            public Invocation Invocation => this.invocation;
+            public Invocation? Invocation => this.invocation;
 
             public IEnumerable<Match> Matches
             {
@@ -264,7 +264,7 @@ public IEnumerable<Match> Matches
                 }
             }
 
-            public Recorder Next => (Awaitable.TryGetResultRecursive(this.returnValue) as IProxy)?.Interceptor as Recorder;
+            public Recorder? Next => (Awaitable.TryGetResultRecursive(this.returnValue) as IProxy)?.Interceptor as Recorder;
 
             public void Intercept(Invocation invocation)
             {

src/Moq/AsInterface.cs

@@ -19,9 +19,9 @@ public AsInterface(Mock owner)
 
         internal override List<Type> AdditionalInterfaces => this.owner.AdditionalInterfaces;
 
-        internal override Dictionary<Type, object> ConfiguredDefaultValues => this.owner.ConfiguredDefaultValues;
+        internal override Dictionary<Type, object?> ConfiguredDefaultValues => this.owner.ConfiguredDefaultValues;
 
-        internal override object[] ConstructorArguments => this.owner.ConstructorArguments;
+        internal override object?[] ConstructorArguments => this.owner.ConstructorArguments;
 
         internal override InvocationCollection MutableInvocations => this.owner.MutableInvocations;
 
@@ -49,7 +49,7 @@ public override DefaultValueProvider DefaultValueProvider
 
         public override TInterface Object
         {
-            get { return this.owner.Object as TInterface; }
+            get { return (TInterface)this.owner.Object; }
         }
 
         internal override SetupCollection MutableSetups => this.owner.MutableSetups;
@@ -72,7 +72,7 @@ protected override object OnGetObject()
 
         public override string ToString()
         {
-            return this.owner.ToString();
+            return this.owner.ToString()!;
         }
     }
 }

src/Moq/Async/Awaitable.cs

@@ -14,7 +14,7 @@ static class Awaitable
         ///   this method will return <c>42</c>.
         /// </remarks>
         /// <param name="obj">The (possibly awaitable) object to be "unwrapped".</param>
-        public static object TryGetResultRecursive(object obj)
+        public static object? TryGetResultRecursive(object? obj)
         {
             if (obj != null
                 && AwaitableFactory.TryGet(obj.GetType()) is { } awaitableFactory

src/Moq/Async/AwaitableFactory.cs

@@ -27,7 +27,7 @@ static IAwaitableFactory Create(Type awaitableFactoryType, Type awaitableType)
         {
             return (IAwaitableFactory)Activator.CreateInstance(
                 awaitableFactoryType.MakeGenericType(
-                    awaitableType.GetGenericArguments()));
+                    awaitableType.GetGenericArguments()))!;
         }
 
         public static IAwaitableFactory? TryGet(Type type)

src/Moq/Async/AwaitableFactory`1.cs

@@ -14,12 +14,13 @@ namespace Moq.Async
     ///   for awaitables that do not produce a result when awaited.
     /// </summary>
     abstract class AwaitableFactory<TAwaitable> : IAwaitableFactory
+        where TAwaitable : notnull
     {
         Type IAwaitableFactory.ResultType => typeof(void);
 
         public abstract TAwaitable CreateCompleted();
 
-        object IAwaitableFactory.CreateCompleted(object result)
+        object IAwaitableFactory.CreateCompleted(object? result)
         {
             Debug.Assert(result == null);
 
@@ -50,7 +51,7 @@ Expression IAwaitableFactory.CreateResultExpression(Expression awaitableExpressi
             return new AwaitExpression(awaitableExpression, this);
         }
 
-        bool IAwaitableFactory.TryGetResult(object awaitable, out object result)
+        bool IAwaitableFactory.TryGetResult(object awaitable, out object? result)
         {
             Debug.Assert(awaitable is TAwaitable);
 

src/Moq/Async/AwaitableFactory`2.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
 
@@ -14,16 +15,18 @@ namespace Moq.Async
     ///   for awaitables that produce a result when awaited.
     /// </summary>
     abstract class AwaitableFactory<TAwaitable, TResult> : IAwaitableFactory
+        where TAwaitable : notnull
     {
         public Type ResultType => typeof(TResult);
 
         public abstract TAwaitable CreateCompleted(TResult result);
 
-        object IAwaitableFactory.CreateCompleted(object result)
+        object IAwaitableFactory.CreateCompleted(object? result)
         {
+            // TODO: result should only be null if TResult is a nullable type.
             Debug.Assert(result is TResult || result == null);
 
-            return this.CreateCompleted((TResult)result);
+            return this.CreateCompleted((TResult)result!);
         }
 
         public abstract TAwaitable CreateFaulted(Exception exception);
@@ -45,11 +48,15 @@ object IAwaitableFactory.CreateFaulted(IEnumerable<Exception> exceptions)
             return this.CreateFaulted(exceptions);
         }
 
+#if NULLABLE_REFERENCE_TYPES
+        public abstract bool TryGetResult(TAwaitable awaitable, [MaybeNullWhen(false)] out TResult result);
+#else
         public abstract bool TryGetResult(TAwaitable awaitable, out TResult result);
+#endif
 
         public abstract Expression CreateResultExpression(Expression awaitableExpression);
 
-        bool IAwaitableFactory.TryGetResult(object awaitable, out object result)
+        bool IAwaitableFactory.TryGetResult(object awaitable, out object? result)
         {
             Debug.Assert(awaitable is TAwaitable);
 

src/Moq/Async/IAwaitableFactory.cs

@@ -11,14 +11,14 @@ interface IAwaitableFactory
     {
         Type ResultType { get; }
 
-        object CreateCompleted(object result = null);
+        object CreateCompleted(object? result = null);
 
         object CreateFaulted(Exception exception);
 
         object CreateFaulted(IEnumerable<Exception> exceptions);
 
         Expression CreateResultExpression(Expression awaitableExpression);
 
-        bool TryGetResult(object awaitable, out object result);
+        bool TryGetResult(object awaitable, out object? result);
     }
 }

src/Moq/Async/TaskFactory.cs

@@ -19,7 +19,7 @@ sealed class TaskFactory : AwaitableFactory<Task>
 
         public override Task CreateCompleted()
         {
-            return Task.FromResult<object>(default);
+            return Task.CompletedTask;
         }
 
         public override Task CreateFaulted(Exception exception)

src/Moq/Async/TaskFactory`1.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -33,10 +34,14 @@ public override Expression CreateResultExpression(Expression awaitableExpression
         {
             return Expression.MakeMemberAccess(
                 awaitableExpression,
-                typeof(Task<TResult>).GetProperty(nameof(Task<TResult>.Result)));
+                typeof(Task<TResult>).GetProperty(nameof(Task<TResult>.Result))!);
         }
 
-        public override bool TryGetResult(Task<TResult> task, out TResult result)
+#if NULLABLE_REFERENCE_TYPES
+        public override bool TryGetResult(Task<TResult> task, [MaybeNullWhen(false)] out TResult result)
+#else
+        public override bool TryGetResult(Task<TResult> task, out TResult? result)
+#endif
         {
             if (task.Status == TaskStatus.RanToCompletion)
             {

src/Moq/Async/ValueTaskFactory`1.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 
@@ -33,10 +34,14 @@ public override Expression CreateResultExpression(Expression awaitableExpression
         {
             return Expression.MakeMemberAccess(
                 awaitableExpression,
-                typeof(ValueTask<TResult>).GetProperty(nameof(ValueTask<TResult>.Result)));
+                typeof(ValueTask<TResult>).GetProperty(nameof(ValueTask<TResult>.Result))!);
         }
 
+#if NULLABLE_REFERENCE_TYPES
+        public override bool TryGetResult(ValueTask<TResult> valueTask, [MaybeNullWhen(false)] out TResult result)
+#else
         public override bool TryGetResult(ValueTask<TResult> valueTask, out TResult result)
+#endif
         {
             if (valueTask.IsCompletedSuccessfully)
             {

src/Moq/Behaviors/RaiseEvent.cs

@@ -11,10 +11,10 @@ sealed class RaiseEvent : Behavior
     {
         Mock mock;
         LambdaExpression expression;
-        Delegate eventArgsFunc;
-        object[] eventArgsParams;
+        Delegate? eventArgsFunc;
+        object?[]? eventArgsParams;
 
-        public RaiseEvent(Mock mock, LambdaExpression expression, Delegate eventArgsFunc, object[] eventArgsParams)
+        public RaiseEvent(Mock mock, LambdaExpression expression, Delegate? eventArgsFunc, object?[]? eventArgsParams)
         {
             Debug.Assert(mock != null);
             Debug.Assert(expression != null);
@@ -28,22 +28,22 @@ public RaiseEvent(Mock mock, LambdaExpression expression, Delegate eventArgsFunc
 
         public override void Execute(Invocation invocation)
         {
-            object[] args;
+            object?[] args;
 
             if (this.eventArgsParams != null)
             {
                 args = this.eventArgsParams;
             }
             else
             {
-                var argsFuncType = this.eventArgsFunc.GetType();
+                var argsFuncType = this.eventArgsFunc!.GetType();
                 if (argsFuncType.IsGenericType && argsFuncType.GetGenericArguments().Length == 1)
                 {
-                    args = new object[] { this.mock.Object, this.eventArgsFunc.InvokePreserveStack() };
+                    args = new object?[] { this.mock.Object, this.eventArgsFunc.InvokePreserveStack() };
                 }
                 else
                 {
-                    args = new object[] { this.mock.Object, this.eventArgsFunc.InvokePreserveStack(invocation.Arguments) };
+                    args = new object?[] { this.mock.Object, this.eventArgsFunc.InvokePreserveStack(invocation.Arguments) };
                 }
             }
 

src/Moq/Behaviors/ReturnBaseOrDefaultValue.cs

@@ -31,7 +31,7 @@ public override void Execute(Invocation invocation)
 				var tryCallDefaultInterfaceImplementation = false;
 #endif
 
-                var declaringType = method.DeclaringType;
+                var declaringType = method.DeclaringType!;
                 if (declaringType.IsInterface)
                 {
                     if (this.mock.MockedType.IsInterface)

src/Moq/Behaviors/ReturnComputedValue.cs

@@ -8,9 +8,9 @@ namespace Moq.Behaviors
 {
     sealed class ReturnComputedValue : Behavior
     {
-        readonly Func<IInvocation, object> valueFactory;
+        readonly Func<IInvocation, object?> valueFactory;
 
-        public ReturnComputedValue(Func<IInvocation, object> valueFactory)
+        public ReturnComputedValue(Func<IInvocation, object?> valueFactory)
         {
             Debug.Assert(valueFactory != null);
 

src/Moq/Behaviors/ReturnValue.cs

@@ -5,14 +5,14 @@ namespace Moq.Behaviors
 {
     sealed class ReturnValue : Behavior
     {
-        readonly object value;
+        readonly object? value;
 
-        public ReturnValue(object value)
+        public ReturnValue(object? value)
         {
             this.value = value;
         }
 
-        public object Value => this.value;
+        public object? Value => this.value;
 
         public override void Execute(Invocation invocation)
         {

src/Moq/Behaviors/ThrowComputedException.cs

@@ -8,9 +8,9 @@
 {
     sealed class ThrowComputedException : Behavior
     {
-        readonly Func<IInvocation, Exception> exceptionFactory;
+        readonly Func<IInvocation, Exception?> exceptionFactory;
 
-        public ThrowComputedException(Func<IInvocation, Exception> exceptionFactory)
+        public ThrowComputedException(Func<IInvocation, Exception?> exceptionFactory)
         {
             Debug.Assert(exceptionFactory != null);
 
@@ -19,7 +19,8 @@
 
         public override void Execute(Invocation invocation)
         {
+            // TODO: Technically this permits `throw null` here.
             throw this.exceptionFactory.Invoke(invocation);
         }
     }
 }

src/Moq/Capture.cs

@@ -76,7 +76,7 @@ public static T In<T>(IList<T> collection, Expression<Func<T, bool>> predicate)
         public static T With<T>(CaptureMatch<T> match)
         {
             Match.Register(match);
-            return default(T);
+            return default(T)!;
         }
     }
 }