Consolidate new API and documentation

Now that the new overload for `Returns` has had to become non-generic,
so should the new `Callback` overload (for consistency).

Also forgot to update the XML documentation comments, bring them in
line again with the actual method signatures.

Source/Language/ICallback.cs

@@ -53,23 +53,21 @@ public partial interface ICallback : IFluentInterface
  /// <summary>
  /// Specifies a callback of any delegate type to invoke when the method is called.
  /// This overload specifically allows you to define callbacks for methods with by-ref parameters.
+ /// By-ref parameters can be assigned to.
  /// </summary>
- /// <typeparam name="TActionDelegate">
- /// Delegate type of which <paramref name="callback"/> is an instance.
- /// Must have return type <c>void</c> (C#) or be a <c>Sub</c> (VB.NET).
- /// </typeparam>
- /// <param name="callback">The callback method to invoke.</param>
+ /// <param name="callback">The callback method to invoke. Must have return type <c>void</c> (C#) or be a <c>Sub</c> (VB.NET).</param>
  /// <example>
  /// Invokes the given callback with the concrete invocation argument value. You can modify
  /// by-ref parameters inside the callback.
  /// <code>
- /// delegate void ExecuteHandler(ref Command command);
+ /// delegate void ExecuteAction(ref Command command);
  ///
- /// mock.Setup(x => x.Execute(ref command))
- /// .Callback&lt;ExecuteHandler&gt;((ref Command _) => Console.WriteLine("Executing command..."));
+ /// Command c = ...;
+ /// mock.Setup(x => x.Execute(ref c))
+ /// .Callback(new ExecuteAction((ref Command command) => Console.WriteLine("Executing command...")));
  /// </code>
  /// </example>
- ICallbackResult Callback<TActionDelegate>(TActionDelegate callback);
+ ICallbackResult Callback(Delegate callback);
 
  /// <summary>
  /// Specifies a callback to invoke when the method is called.
@@ -117,23 +115,21 @@ public partial interface ICallback<TMock, TResult> : IFluentInterface
  /// <summary>
  /// Specifies a callback of any delegate type to invoke when the method is called.
  /// This overload specifically allows you to define callbacks for methods with by-ref parameters.
+ /// By-ref parameters can be assigned to.
  /// </summary>
- /// <typeparam name="TActionDelegate">
- /// Delegate type of which <paramref name="callback"/> is an instance.
- /// Must have return type <c>void</c> (C#) or be a <c>Sub</c> (VB.NET).
- /// </typeparam>
- /// <param name="callback">The callback method to invoke.</param>
+ /// <param name="callback">The callback method to invoke. Must have return type <c>void</c> (C#) or be a <c>Sub</c> (VB.NET).</param>
  /// <example>
  /// Invokes the given callback with the concrete invocation argument value. You can modify
  /// by-ref parameters inside the callback.
  /// <code>
- /// delegate void ExecuteHandler(ref Command command);
+ /// delegate void ExecuteAction(ref Command command);
  ///
- /// mock.Setup(x => x.Execute(ref command))
- /// .Callback&lt;ExecuteHandler&gt;((ref Command _) => Console.WriteLine("Executing command..."));
+ /// Command c = ...;
+ /// mock.Setup(x => x.Execute(ref c))
+ /// .Callback(new ExecuteAction((ref Command command) => Console.WriteLine("Executing command...")));
  /// </code>
  /// </example>
- IReturnsThrows<TMock, TResult> Callback<TActionDelegate>(TActionDelegate callback);
+ IReturnsThrows<TMock, TResult> Callback(Delegate callback);
 
  /// <summary>
  /// Specifies a callback to invoke when the method is called.

Source/Language/IReturns.cs

@@ -68,15 +68,19 @@ public partial interface IReturns<TMock, TResult> : IFluentInterface
 
  /// <summary>
  /// Specifies a function that will calculate the value to return from the method.
+ /// This overload specifically allows you to specify a function with by-ref parameters.
+ /// Those by-ref parameters can be assigned to (though you should probably do that from
+ /// a <c>Callback</c> instead).
  /// </summary>
  /// <param name="valueFunction">The function that will calculate the return value.</param>
  /// <example group="returns">
  /// Return a calculated value when the method is called:
  /// <code>
- /// delegate bool ExecuteHandler(ref Command command);
+ /// delegate bool ExecuteFunc(ref Command command);
  ///
- /// mock.Setup(x => x.Execute(ref command))
- /// .Returns&lt;ExecuteHandler&gt;((ref Command command) => command.IsExecutable);
+ /// Command c = ...;
+ /// mock.Setup(x => x.Execute(ref c))
+ /// .Returns(new ExecuteFunc((ref Command command) => command.IsExecutable));
  /// </code>
  /// </example>
  IReturnsResult<TMock> Returns(Delegate valueFunction);

Source/MethodCall.cs

@@ -322,20 +322,19 @@ public ICallbackResult Callback(Action callback)
  return this;
  }
 
- public ICallbackResult Callback<TActionDelegate>(TActionDelegate callback)
+ public ICallbackResult Callback(Delegate callback)
  {
  if (callback == null)
  {
  throw new ArgumentNullException(nameof(callback));
  }
 
- var callbackDelegate = callback as Delegate;
- if (callbackDelegate == null || callbackDelegate.GetMethodInfo().ReturnType != typeof(void))
+ if (callback.GetMethodInfo().ReturnType != typeof(void))
  {
  throw new ArgumentException(Resources.InvalidCallbackNotADelegateWithReturnTypeVoid, nameof(callback));
  }
 
- this.SetCallbackWithArguments(callbackDelegate);
+ this.SetCallbackWithArguments(callback);
  return this;
  }
 

Source/MethodCallReturn.cs

@@ -136,9 +136,9 @@ public IReturnsResult<TMock> CallBase()
  return this;
  }
 
- IReturnsThrows<TMock, TResult> ICallback<TMock, TResult>.Callback<TActionDelegate>(TActionDelegate callback)
+ IReturnsThrows<TMock, TResult> ICallback<TMock, TResult>.Callback(Delegate callback)
  {
- base.Callback<TActionDelegate>(callback);
+ base.Callback(callback);
  return this;
  }