#31: Add support for shimming operators

README.md

@@ -1,6 +1,8 @@
-[![Build status](https://dev.azure.com/palmund/Pose/_apis/build/status/Pose-CI?branchName=master)](https://dev.azure.com/palmund/Pose/_build/latest?definitionId=12)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![NuGet version](https://badge.fury.io/nu/Poser.svg)](https://www.nuget.org/packages/Poser)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Build status](https://dev.azure.com/palmund/Pose/_apis/build/status/Pose-CI?branchName=master&Label=build)](https://dev.azure.com/palmund/Pose/_build/latest?definitionId=12)
+[![NuGet version](https://img.shields.io/nuget/v/Poser?logo=nuget)](https://www.nuget.org/packages/Poser)
+[![NuGet preview version](https://img.shields.io/nuget/vpre/Poser?logo=nuget)](https://www.nuget.org/packages/Poser)
+
 # Poser
 
 Poser allows you to replace any .NET method (including static and non-virtual) with a delegate. It is similar to [Microsoft Fakes](https://msdn.microsoft.com/en-us/library/hh549175.aspx) but unlike it Poser is implemented _entirely_ in managed code (Reflection Emit API). Everything occurs at runtime and in-memory, no unmanaged Profiling APIs and no file system pollution with re-written assemblies.
@@ -115,6 +117,12 @@ Shim structShim = Shim.Replace(() => Is.A<MyStruct>().DoSomething()).With(
 
 _Note: You cannot shim methods on specific instances of Value Types_
 
+### Shim operators
+
+```csharp
+var operatorShim = Shim.Replace(() => Is.A<TimeSpan>() + Is.A<TimeSpan>()).With(
+    delegate(TimeSpan l, TimeSpan r) { return TimeSpan.Zero; });
+```
 ### Isolating your code
 
 ```csharp
@@ -135,10 +143,48 @@ PoseContext.Isolate(() =>
 
     // Outputs "doing someting else with myClass"
     myClass.DoSomething();
+
+    // Outputs '00:00:00'
+    Console.WriteLine(TimeSpan.FromDays(1) + TimeSpan.FromSeconds(2));
 
-}, consoleShim, dateTimeShim, classPropShim, classShim, myClassShim, structShim);
+}, consoleShim, dateTimeShim, classPropShim, classShim, myClassShim, structShim, operatorShim);
 ```
 
+## Shimming operators
+Operator shimming requires that the class/struct overloads the operator in question.
+
+Poser supports shimming operators of the following kind:
+* Arithmetic
+  * `+x`
+  * `-x`
+  * `!x`
+  * `~x`
+  * `x + y`
+  * `x - y`
+  * `x / y`
+  * `x % y`
+  * `x & y`
+  * `x | y`
+  * `x ^ y`
+  * `x << y`
+  * `x >> y`
+* Equality
+  * `x == y`
+  * `x != y`
+* Comparison
+  * `x < y`
+  * `x > y`
+  * `x <= y`
+  * `x >= y`
+
+In addition to this, both implicit and explicit conversion operators are supported.
+
+### Unsupported operators
+Shimming of the following operators is not supported:
+- `true` and `false` because I cannot find a good way to express the operation in an expression tree.
+- `x >>> y` because expression trees cannot contain this operator. This is a limitation on the part of the compiler.
+- `++` and `--` because these cannot be expressed in an expression tree.
+
 ## Caveats & Limitations
 
 * **Breakpoints** - At this time any breakpoints set anywhere in the isolated code and its execution path will not be hit. However, breakpoints set within a shim replacement delegate are hit.

nuget/Poser.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
   <metadata>
     <id>Poser</id>
-    <version>2.0.0</version>
+    <version>2.0.1</version>
     <title>Pose</title>
     <authors>Søren Guldmund</authors>
     <owners>Søren Guldmund</owners>
@@ -16,7 +16,7 @@
     <copyright>Copyright 2024</copyright>
 	  <readme>docs\README.md</readme>
     <releaseNotes>
-      Provide better exception message when we cannot create instance.
+      Fix bug where `Enum.IsDefined` could not be called from within `PoseContext.Isolate`.
 	  </releaseNotes>
 
     <dependencies>

src/Pose/Exceptions/InvalidShimSignatureException.cs

@@ -1,17 +1,9 @@
 namespace Pose.Exceptions
 {
     using System;
-    using System.Runtime.Serialization;
 
-    [Serializable]
-    internal class InvalidShimSignatureException : Exception
+    public class InvalidShimSignatureException : Exception
     {
-        public InvalidShimSignatureException() { }
         public InvalidShimSignatureException(string message) : base(message) { }
-        public InvalidShimSignatureException(string message, Exception inner) : base(message, inner) { }
-
-#if !NET8_0_OR_GREATER
-        protected InvalidShimSignatureException(SerializationInfo info, StreamingContext context) : base(info, context) { }
-#endif
     }
 }

src/Pose/Exceptions/MethodRewriteException.cs

@@ -1,19 +1,9 @@
 namespace Pose.Exceptions
 {
     using System;
-    using System.Runtime.Serialization;
 
-    [Serializable]
     public class MethodRewriteException : Exception
     {
-        public MethodRewriteException() { }
-
-#if !NET8_0_OR_GREATER
-        protected MethodRewriteException(SerializationInfo info, StreamingContext context) : base(info, context) { }
-#endif
-
         public MethodRewriteException(string message) : base(message) { }
-
-        public MethodRewriteException(string message, Exception innerException) : base(message, innerException) { }
     }
 }

src/Pose/Exceptions/UnsupportedExpressionException.cs

@@ -0,0 +1,9 @@
+namespace Pose.Exceptions
+{
+    using System;
+
+    public class UnsupportedExpressionException : Exception
+    {
+        public UnsupportedExpressionException(string message) : base(message) { }
+    }
+}

src/Pose/Extensions/ExpressionTypeExtensions.cs

@@ -0,0 +1,36 @@
+using System.Linq.Expressions;
+
+namespace Pose.Extensions
+{
+    internal static class ExpressionTypeExtensions
+    {
+        public static bool IsOverloadableOperator(this ExpressionType expressionType)
+        {
+            switch (expressionType)
+            {
+                case ExpressionType.Add:
+                case ExpressionType.UnaryPlus:
+                case ExpressionType.Negate:
+                case ExpressionType.Not:
+                case ExpressionType.Subtract:
+                case ExpressionType.Multiply:
+                case ExpressionType.Divide:
+                case ExpressionType.LeftShift:
+                case ExpressionType.RightShift:
+                case ExpressionType.Modulo:
+                case ExpressionType.ExclusiveOr:
+                case ExpressionType.And:
+                case ExpressionType.Equal:
+                case ExpressionType.NotEqual:
+                case ExpressionType.LessThan:
+                case ExpressionType.GreaterThan:
+                case ExpressionType.LessThanOrEqual:
+                case ExpressionType.GreaterThanOrEqual:
+                case ExpressionType.Or:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+    }
+}

src/Pose/Extensions/ILGeneratorExtensions.cs

@@ -1,9 +1,11 @@
 namespace Pose.Extensions
 {
     using System;
+    using System.Diagnostics.CodeAnalysis;
     using System.Reflection;
     using System.Reflection.Emit;
 
+    [ExcludeFromCodeCoverage(Justification = "Used only internally when printing out IL instructions")]
     internal static class ILGeneratorExtensions
     {
         public static byte[] GetILBytes(this ILGenerator ilGenerator)

src/Pose/Helpers/ShimHelper.cs

@@ -4,6 +4,7 @@
 using System.Reflection;
 
 using Pose.Exceptions;
+using Pose.Extensions;
 
 namespace Pose.Helpers
 {
@@ -25,7 +26,7 @@ public static MethodBase GetMethodFromExpression(Expression expression, bool set
                         }
                         else
                         {
-                            throw new NotImplementedException("Unsupported expression");
+                            throw new UnsupportedExpressionException($"Expression (of type {expression.GetType()}) with NodeType '{expression.NodeType}' is not supported");
                         }
                     }
                 case ExpressionType.Call:
@@ -36,9 +37,46 @@ public static MethodBase GetMethodFromExpression(Expression expression, bool set
                     var newExpression = expression as NewExpression ?? throw new Exception($"Cannot cast expression to {nameof(NewExpression)}");
                     instanceOrType = null;
                     return newExpression.Constructor;
+                case ExpressionType.Convert:
+                case ExpressionType.Not:
+                case ExpressionType.Negate:
+                case ExpressionType.UnaryPlus:
+                    var unaryExpression = expression as UnaryExpression ?? throw new Exception($"Cannot cast expression to {nameof(UnaryExpression)}");
+                    instanceOrType = null;
+                    return unaryExpression.Method ?? throw new Exception(GetExceptionMessage(expression));
+                case ExpressionType.Add:
+                case ExpressionType.Subtract:
+                case ExpressionType.Multiply:
+                case ExpressionType.Divide:
+                case ExpressionType.LeftShift:
+                case ExpressionType.RightShift:
+                case ExpressionType.Modulo:
+                case ExpressionType.ExclusiveOr:
+                case ExpressionType.And:
+                case ExpressionType.Equal:
+                case ExpressionType.NotEqual:
+                case ExpressionType.LessThan:
+                case ExpressionType.GreaterThan:
+                case ExpressionType.LessThanOrEqual:
+                case ExpressionType.GreaterThanOrEqual:
+                case ExpressionType.Or:
+                    var binaryExpression = expression as BinaryExpression ?? throw new Exception($"Cannot cast expression to {nameof(BinaryExpression)}");
+                    instanceOrType = null;
+                    return binaryExpression.Method ?? throw new Exception(GetExceptionMessage(expression));
                 default:
-                    throw new NotImplementedException("Unsupported expression");
+                    throw new UnsupportedExpressionException($"Expression (of type {expression.GetType()}) with NodeType '{expression.NodeType}' is not supported");
+            }
+        }
+
+        private static string GetExceptionMessage(Expression expression)
+        {
+            if (expression.NodeType.IsOverloadableOperator())
+            {
+                return
+                    $"Cannot shim the {expression.NodeType} operator on {expression.Type} because the type itself does not overload this operator.";
             }
+
+            return $"The expression for node type {expression.NodeType} could not be mapped to a method";
         }
 
         public static void ValidateReplacementMethodSignature(MethodBase original, MethodInfo replacement, Type type, bool setter)
@@ -74,17 +112,20 @@ public static void ValidateReplacementMethodSignature(MethodBase original, Metho
                     throw new InvalidShimSignatureException("ValueType instances must be passed by ref");
             }
 
-            var expectedType = (isValueType && !isStaticOrConstructor ? validOwningType.MakeByRefType() : validOwningType);
-            if (expectedType != shimOwningType)
-                throw new InvalidShimSignatureException($"Mismatched instance types. Expected {expectedType.FullName}. Got {shimOwningType.FullName}");
+            var expectedOwningType = (isValueType && !isStaticOrConstructor ? validOwningType.MakeByRefType() : validOwningType);
+            if (expectedOwningType != shimOwningType)
+                throw new InvalidShimSignatureException($"Mismatched instance types. Expected {expectedOwningType.FullName}. Got {shimOwningType.FullName}. If you are shimming an instance method, then the first parameter to the replacement must be an instance of the type.");
 
             if (validParameterTypes.Length != shimParameterTypes.Length)
                 throw new InvalidShimSignatureException($"Parameters count do not match. Expected {validParameterTypes.Length}. Got {shimParameterTypes.Length}");
 
             for (var i = 0; i < validParameterTypes.Length; i++)
             {
-                if (validParameterTypes.ElementAt(i) != shimParameterTypes.ElementAt(i))
-                    throw new InvalidShimSignatureException($"Parameter types at {i} do not match");
+                var expectedType = validParameterTypes.ElementAt(i);
+                var actualType = shimParameterTypes.ElementAt(i);
+
+                if (expectedType != actualType)
+                    throw new InvalidShimSignatureException($"Parameter types at {i} do not match. Expected '{expectedType}' but found {actualType}'");
             }
         }
 

src/Pose/IL/MethodRewriter.cs

@@ -110,7 +110,7 @@ public MethodBase Rewrite()
             var switchTargets = instructions
                 .Where(i => i.Operand is Instruction[])
                 .Select(i => i.Operand as Instruction[]);
-
+            
             foreach (var switchInstructions in switchTargets)
             {
                 if (switchInstructions == null) throw new Exception("The impossible happened");
@@ -119,13 +119,13 @@ public MethodBase Rewrite()
                     targetInstructions.TryAdd(instruction.Offset, ilGenerator.DefineLabel());
             }
 
-#if DEBUG
+#if TRACE
             Console.WriteLine("\n" + _method);
 #endif
 
             foreach (var instruction in instructions)
             {
-#if DEBUG
+#if TRACE
                 Console.WriteLine(instruction);
 #endif
 
@@ -181,7 +181,7 @@ public MethodBase Rewrite()
                 }
             }
 
-#if DEBUG
+#if TRACE
             var ilBytes = ilGenerator.GetILBytes();
             var browsableDynamicMethod = new BrowsableDynamicMethod(dynamicMethod, new DynamicMethodBody(ilBytes, locals));
             Console.WriteLine("\n" + dynamicMethod);