Support for Memory<T>/ReadOnlyMemory<T> outputs + formatting. Resolves #317.

kindermannhubert · kindermannhubert · commit 4d80331725ed · 2024-04-01T17:27:51.000+02:00
diff --git a/CSharpRepl.Services/Roslyn/Formatting/CustomObjectFormatters/IEnumerableFormatter.cs b/CSharpRepl.Services/Roslyn/Formatting/CustomObjectFormatters/IEnumerableFormatter.cs
@@ -143,30 +143,27 @@ private static bool AppendHeader(StyledStringBuilder sb, IEnumerable value, Form
         if (type.FullName?.EndsWith(typeof(__CSharpRepl_RuntimeHelper.CharSpanOutput).FullName!) == true)
         {
             if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.Text))?.GetValue(value) is string text &&
-                type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.SpanWasReadOnly))?.GetValue(value) is bool readOnly)
+                type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.OriginalType))?.GetValue(value) is Type originalType)
             {
-                type = readOnly ? typeof(ReadOnlySpan<char>) : typeof(Span<char>);
-
-                AppendTypeName(isArray: false);
+                AppendTypeName(originalType, isArray: false);
                 sb.Append(Environment.NewLine);
                 sb.Append(formatter.FormatObjectToText(text, Level.FirstDetailed));
-                return false; 
+                return false;
             }
         }
         else if (type.FullName?.EndsWith(typeof(__CSharpRepl_RuntimeHelper.SpanOutput).FullName!) == true)
         {
-            if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.Array))?.GetValue(value)  is Array array &&
-                type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.SpanWasReadOnly))?.GetValue(value) is bool readOnly)
+            if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.OriginalType))?.GetValue(value) is Type originalType)
             {
-                type = (readOnly ? typeof(ReadOnlySpan<>) : typeof(Span<>)).MakeGenericType(array.GetType().GetElementType() ?? array.GetType());
+                type = originalType;
             }
         }
 
         var isArray = value is Array;
-        AppendTypeName(isArray);
+        AppendTypeName(type, isArray);
         return true;
 
-        void AppendTypeName(bool isArray)
+        void AppendTypeName(Type type, bool isArray)
         {
             sb.Append(
                 formatter.FormatTypeName(
diff --git a/CSharpRepl.Services/Roslyn/Formatting/FormattedObject.cs b/CSharpRepl.Services/Roslyn/Formatting/FormattedObject.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Collections.Generic;
+﻿using System.Collections.Generic;
 using Spectre.Console.Rendering;
 
 namespace CSharpRepl.Services.Roslyn.Formatting;
diff --git a/CSharpRepl.Services/Roslyn/RoslynServices.cs b/CSharpRepl.Services/Roslyn/RoslynServices.cs
@@ -462,17 +462,20 @@ private async Task<string> InterceptInputWhenRefStructReturnNeedsToBeHandled(str
     {
         await Initialization.ConfigureAwait(false);
 
-        if ((await scriptRunner.HasValueReturningStatement(input, cancellationToken).ConfigureAwait(false)).TryGet(out var result) &&
-            result.Type.IsRefLikeType)
+        if ((await scriptRunner.HasValueReturningStatement(input, cancellationToken).ConfigureAwait(false)).TryGet(out var result))
         {
             var root = result.Expression.SyntaxTree.GetRoot(cancellationToken);
             var expressionToBeWrapped = result.Expression;
-            ExpressionSyntax wrappedExpression;
+            var wrappedExpression = expressionToBeWrapped;
             if (result.Type is { Name: "Span" or "ReadOnlySpan", ContainingNamespace.Name: "System" })
             {
                 wrappedExpression = Wrap(nameof(__CSharpRepl_RuntimeHelper.HandleSpanOutput), result.Expression);
             }
-            else
+            else if (result.Type is { Name: "Memory" or "ReadOnlyMemory", ContainingNamespace.Name: "System" })
+            {
+                wrappedExpression = Wrap(nameof(__CSharpRepl_RuntimeHelper.HandleMemoryOutput), result.Expression);
+            }
+            else if (result.Type.IsRefLikeType)
             {
                 var toStringMethod = result.Type
                     .GetMembers(nameof(ToString))
@@ -484,22 +487,26 @@ private async Task<string> InterceptInputWhenRefStructReturnNeedsToBeHandled(str
                 {
                     expressionToBeWrapped = SyntaxFactory.InvocationExpression(
                         SyntaxFactory.MemberAccessExpression(
-                            SyntaxKind.SimpleMemberAccessExpression, 
-                            expressionToBeWrapped, 
+                            SyntaxKind.SimpleMemberAccessExpression,
+                            expressionToBeWrapped,
                             SyntaxFactory.IdentifierName(nameof(ToString))));
                 }
                 else
                 {
                     expressionToBeWrapped = SyntaxFactory.LiteralExpression(
-                        SyntaxKind.StringLiteralExpression, 
+                        SyntaxKind.StringLiteralExpression,
                         SyntaxFactory.Literal($"Cannot output a value of '{result.Type.Name}' because it's a ref-struct. It has to override ToString() to see its value."));
                 }
                 wrappedExpression = Wrap(
                     nameof(__CSharpRepl_RuntimeHelper.HandleRefStructOutput),
                     expressionToBeWrapped);
             }
-            root = root.ReplaceNode(result.Expression, wrappedExpression);
-            return root.GetText().ToString();
+
+            if (result.Expression != wrappedExpression)
+            {
+                root = root.ReplaceNode(result.Expression, wrappedExpression);
+                return root.GetText().ToString();
+            }
         }
         return input;
 
@@ -515,4 +522,4 @@ static ExpressionSyntax Wrap(string runtimeHelperMethod, ExpressionSyntax expres
                                     SyntaxFactory.Argument(
                                         expressionToBeWrapped))));
     }
-}
+}
diff --git a/CSharpRepl.Services/RuntimeHelper.cs b/CSharpRepl.Services/RuntimeHelper.cs
@@ -6,51 +6,57 @@
 
 public static class __CSharpRepl_RuntimeHelper
 {
-    public static SpanOutput HandleSpanOutput<T>(System.Span<T> span) => SpanOutput.Create<T>(span, false);
-    public static SpanOutput HandleSpanOutput<T>(System.ReadOnlySpan<T> span) => SpanOutput.Create(span, true);
+    public static SpanOutput HandleSpanOutput<T>(System.Span<T> span) => SpanOutput.Create<T>(span, typeof(System.Span<T>));
+    public static SpanOutput HandleSpanOutput<T>(System.ReadOnlySpan<T> span) => SpanOutput.Create(span, typeof(System.ReadOnlySpan<T>));
 
-    public static CharSpanOutput HandleSpanOutput(System.Span<char> span) => CharSpanOutput.Create(span, false);
-    public static CharSpanOutput HandleSpanOutput(System.ReadOnlySpan<char> span) => CharSpanOutput.Create(span, true);
+    public static CharSpanOutput HandleSpanOutput(System.Span<char> span) => CharSpanOutput.Create(span, typeof(System.Span<char>));
+    public static CharSpanOutput HandleSpanOutput(System.ReadOnlySpan<char> span) => CharSpanOutput.Create(span, typeof(System.ReadOnlySpan<char>));
+
+    public static SpanOutput HandleMemoryOutput<T>(System.Memory<T> memory) => SpanOutput.Create<T>(memory.Span, typeof(System.Memory<T>));
+    public static SpanOutput HandleMemoryOutput<T>(System.ReadOnlyMemory<T> memory) => SpanOutput.Create(memory.Span, typeof(System.ReadOnlyMemory<T>));
+
+    public static CharSpanOutput HandleMemoryOutput(System.Memory<char> memory) => CharSpanOutput.Create(memory.Span, typeof(System.Memory<char>));
+    public static CharSpanOutput HandleMemoryOutput(System.ReadOnlyMemory<char> memory) => CharSpanOutput.Create(memory.Span, typeof(System.ReadOnlyMemory<char>));
 
     public static RefStructOutput HandleRefStructOutput(string text) => new(text);
 
-    public abstract class SpanOutputBase(int originalLength, bool spanWasReadOnly) 
+    public abstract class SpanOutputBase(int originalLength, System.Type originalType)
         : System.Collections.IEnumerable
     {
         public readonly int OriginalLength = originalLength;
-        public readonly bool SpanWasReadOnly = spanWasReadOnly;
+        public readonly System.Type OriginalType = originalType;
 
         //Necessary for correct output formatting.
         public int Count => OriginalLength;
 
         public abstract System.Collections.IEnumerator GetEnumerator();
     }
 
-    public sealed class SpanOutput(System.Array array, int originalLength, bool spanWasReadOnly) 
-        : SpanOutputBase(originalLength, spanWasReadOnly)
+    public sealed class SpanOutput(System.Array array, int originalLength, System.Type originalType)
+        : SpanOutputBase(originalLength, originalType)
     {
         private const int MaxLength = 1024;
 
-        public readonly System.Array Array = array;
+        private readonly System.Array array = array;
 
-        public override System.Collections.IEnumerator GetEnumerator() => Array.GetEnumerator();
+        public override System.Collections.IEnumerator GetEnumerator() => array.GetEnumerator();
 
-        public static SpanOutput Create<T>(System.ReadOnlySpan<T> span, bool spanWasReadOnly) => new(
+        public static SpanOutput Create<T>(System.ReadOnlySpan<T> span, System.Type originalType) => new(
             span[..System.Math.Min(MaxLength, span.Length)].ToArray(),
             span.Length,
-            spanWasReadOnly);
+            originalType);
     }
 
-    public sealed class CharSpanOutput(string text, int originalLength, bool spanWasReadOnly) 
-        : SpanOutputBase(originalLength, spanWasReadOnly)
+    public sealed class CharSpanOutput(string text, int originalLength, System.Type originalType)
+        : SpanOutputBase(originalLength, originalType)
     {
         private const int MaxLength = 10_000;
 
         public readonly string Text = text;
 
         public override System.Collections.IEnumerator GetEnumerator() => Text.GetEnumerator();
 
-        public static CharSpanOutput Create(System.ReadOnlySpan<char> span, bool spanWasReadOnly)
+        public static CharSpanOutput Create(System.ReadOnlySpan<char> span, System.Type originalType)
         {
             var len = System.Math.Min(MaxLength, span.Length);
             System.Span<char> buffer = stackalloc char[len];
@@ -61,7 +67,7 @@ public static CharSpanOutput Create(System.ReadOnlySpan<char> span, bool spanWas
                 buffer[^2] = '.';
                 buffer[^3] = '.';
             }
-            return new(buffer.ToString(), span.Length, spanWasReadOnly);
+            return new(buffer.ToString(), span.Length, originalType);
         }
     }
 
diff --git a/CSharpRepl.Tests/CompletionTests.cs b/CSharpRepl.Tests/CompletionTests.cs
@@ -2,7 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-using System;
 using System.Linq;
 using System.Threading.Tasks;
 using CSharpRepl.PrettyPromptConfig;
diff --git a/CSharpRepl.Tests/DisassemblerTests.cs b/CSharpRepl.Tests/DisassemblerTests.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.IO;
+﻿using System.IO;
 using System.Threading.Tasks;
 using CSharpRepl.Services;
 using CSharpRepl.Services.Roslyn;
diff --git a/CSharpRepl.Tests/EvaluationTests.cs b/CSharpRepl.Tests/EvaluationTests.cs
@@ -12,7 +12,6 @@
 using CSharpRepl.Services.Roslyn;
 using CSharpRepl.Services.Roslyn.Scripting;
 using Xunit;
-using static PrettyPrompt.Highlighting.FormattedString.TextElementsEnumerator;
 
 namespace CSharpRepl.Tests;
 
@@ -210,19 +209,45 @@ public async Task Evaluate_SpanResult()
         dynamic r1 = Assert.IsType<EvaluationResult.Success>(eval1).ReturnValue.Value;
         Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.SpanOutput)}", r1.GetType().FullName);
         Assert.Equal(3, r1.Count);
-        Assert.Equal(false, r1.SpanWasReadOnly);
+        Assert.Equal(typeof(Span<int>), r1.OriginalType);
 
         var eval2 = await services.EvaluateAsync(@"(ReadOnlySpan<int>)[1,2,3]");
         dynamic r2 = Assert.IsType<EvaluationResult.Success>(eval2).ReturnValue.Value;
         Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.SpanOutput)}", r2.GetType().FullName);
         Assert.Equal(3, r2.Count);
-        Assert.Equal(true, r2.SpanWasReadOnly);
+        Assert.Equal(typeof(ReadOnlySpan<int>), r2.OriginalType);
 
         var eval3 = await services.EvaluateAsync(@"""Hello World"".AsSpan()");
         dynamic r3 = Assert.IsType<EvaluationResult.Success>(eval3).ReturnValue.Value;
         Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput)}", r3.GetType().FullName);
         Assert.Equal(11, r3.Count);
-        Assert.Equal(true, r3.SpanWasReadOnly);
+        Assert.Equal(typeof(ReadOnlySpan<char>), r3.OriginalType);
+    }
+
+    /// <summary>
+    /// https://github.com/waf/CSharpRepl/issues/317
+    /// </summary>
+    [Fact]
+    public async Task Evaluate_MemoryResult()
+    {
+
+        var eval1 = await services.EvaluateAsync(@"new[]{1,2,3}.AsMemory()");
+        dynamic r1 = Assert.IsType<EvaluationResult.Success>(eval1).ReturnValue.Value;
+        Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.SpanOutput)}", r1.GetType().FullName);
+        Assert.Equal(3, r1.Count);
+        Assert.Equal(typeof(Memory<int>), r1.OriginalType);
+
+        var eval2 = await services.EvaluateAsync(@"(ReadOnlyMemory<int>)new[] { 1, 2, 3 }.AsMemory()");
+        dynamic r2 = Assert.IsType<EvaluationResult.Success>(eval2).ReturnValue.Value;
+        Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.SpanOutput)}", r2.GetType().FullName);
+        Assert.Equal(3, r2.Count);
+        Assert.Equal(typeof(ReadOnlyMemory<int>), r2.OriginalType);
+
+        var eval3 = await services.EvaluateAsync(@"""Hello World"".AsMemory()");
+        dynamic r3 = Assert.IsType<EvaluationResult.Success>(eval3).ReturnValue.Value;
+        Assert.EndsWith($"{nameof(__CSharpRepl_RuntimeHelper)}+{nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput)}", r3.GetType().FullName);
+        Assert.Equal(11, r3.Count);
+        Assert.Equal(typeof(ReadOnlyMemory<char>), r3.OriginalType);
     }
 
     /// <summary>
diff --git a/CSharpRepl.Tests/ObjectFormatting/TestFormatter.cs b/CSharpRepl.Tests/ObjectFormatting/TestFormatter.cs
@@ -1,6 +1,5 @@
 ﻿#nullable enable
 
-using System;
 using CSharpRepl.Services;
 using CSharpRepl.Services.Roslyn.Formatting;
 using CSharpRepl.Services.Roslyn.Formatting.CustomObjectFormatters;
diff --git a/CSharpRepl.Tests/RoslynServicesFixture.cs b/CSharpRepl.Tests/RoslynServicesFixture.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Text;
+﻿using System.Text;
 using System.Threading.Tasks;
 using CSharpRepl.Services;
 using CSharpRepl.Services.Roslyn;
diff --git a/CSharpRepl.Tests/RoslynServicesTests.Overloads.cs b/CSharpRepl.Tests/RoslynServicesTests.Overloads.cs
@@ -2,7 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
diff --git a/CSharpRepl.Tests/ScriptArgumentTests.cs b/CSharpRepl.Tests/ScriptArgumentTests.cs
@@ -1,5 +1,4 @@
-﻿using System;
-using System.Threading.Tasks;
+﻿using System.Threading.Tasks;
 using CSharpRepl.Services;
 using CSharpRepl.Services.Roslyn;
 using CSharpRepl.Services.Roslyn.Scripting;
diff --git a/CSharpRepl.Tests/SymbolExplorerTests.cs b/CSharpRepl.Tests/SymbolExplorerTests.cs
@@ -2,7 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-using System;
 using System.Threading.Tasks;
 using CSharpRepl.Services;
 using CSharpRepl.Services.Roslyn;
diff --git a/CSharpRepl.Tests/SyntaxHighlightingTests.cs b/CSharpRepl.Tests/SyntaxHighlightingTests.cs
@@ -2,7 +2,6 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
-using System;
 using System.Linq;
 using System.Threading.Tasks;
 using CSharpRepl.Services;

Original file line number	Diff line number	Diff line change
`@@ -143,30 +143,27 @@ private static bool AppendHeader(StyledStringBuilder sb, IEnumerable value, Form`
`143`	`143`	`if (type.FullName?.EndsWith(typeof(__CSharpRepl_RuntimeHelper.CharSpanOutput).FullName!) == true)`
`144`	`144`	`{`
`145`	`145`	`if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.Text))?.GetValue(value) is string text &&`
`146`		`- type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.SpanWasReadOnly))?.GetValue(value) is bool readOnly)`
	`146`	`+ type.GetField(nameof(__CSharpRepl_RuntimeHelper.CharSpanOutput.OriginalType))?.GetValue(value) is Type originalType)`
`147`	`147`	`{`
`148`		`- type = readOnly ? typeof(ReadOnlySpan<char>) : typeof(Span<char>);`
`149`		`-`
`150`		`- AppendTypeName(isArray: false);`
	`148`	`+ AppendTypeName(originalType, isArray: false);`
`151`	`149`	`sb.Append(Environment.NewLine);`
`152`	`150`	`sb.Append(formatter.FormatObjectToText(text, Level.FirstDetailed));`
`153`		`- return false;`
	`151`	`+ return false;`
`154`	`152`	`}`
`155`	`153`	`}`
`156`	`154`	`else if (type.FullName?.EndsWith(typeof(__CSharpRepl_RuntimeHelper.SpanOutput).FullName!) == true)`
`157`	`155`	`{`
`158`		`- if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.Array))?.GetValue(value) is Array array &&`
`159`		`- type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.SpanWasReadOnly))?.GetValue(value) is bool readOnly)`
	`156`	`+ if (type.GetField(nameof(__CSharpRepl_RuntimeHelper.SpanOutput.OriginalType))?.GetValue(value) is Type originalType)`
`160`	`157`	`{`
`161`		`- type = (readOnly ? typeof(ReadOnlySpan<>) : typeof(Span<>)).MakeGenericType(array.GetType().GetElementType() ?? array.GetType());`
	`158`	`+ type = originalType;`
`162`	`159`	`}`
`163`	`160`	`}`
`164`	`161`
`165`	`162`	`var isArray = value is Array;`
`166`		`- AppendTypeName(isArray);`
	`163`	`+ AppendTypeName(type, isArray);`
`167`	`164`	`return true;`
`168`	`165`
`169`		`- void AppendTypeName(bool isArray)`
	`166`	`+ void AppendTypeName(Type type, bool isArray)`
`170`	`167`	`{`
`171`	`168`	`sb.Append(`
`172`	`169`	`formatter.FormatTypeName(`
Original file line number	Diff line number	Diff line change
`@@ -462,17 +462,20 @@ private async Task<string> InterceptInputWhenRefStructReturnNeedsToBeHandled(str`
`462`	`462`	`{`
`463`	`463`	`await Initialization.ConfigureAwait(false);`
`464`	`464`
`465`		`- if ((await scriptRunner.HasValueReturningStatement(input, cancellationToken).ConfigureAwait(false)).TryGet(out var result) &&`
`466`		`- result.Type.IsRefLikeType)`
	`465`	`+ if ((await scriptRunner.HasValueReturningStatement(input, cancellationToken).ConfigureAwait(false)).TryGet(out var result))`
`467`	`466`	`{`
`468`	`467`	`var root = result.Expression.SyntaxTree.GetRoot(cancellationToken);`
`469`	`468`	`var expressionToBeWrapped = result.Expression;`
`470`		`- ExpressionSyntax wrappedExpression;`
	`469`	`+ var wrappedExpression = expressionToBeWrapped;`
`471`	`470`	`if (result.Type is { Name: "Span" or "ReadOnlySpan", ContainingNamespace.Name: "System" })`
`472`	`471`	`{`
`473`	`472`	`wrappedExpression = Wrap(nameof(__CSharpRepl_RuntimeHelper.HandleSpanOutput), result.Expression);`
`474`	`473`	`}`
`475`		`- else`
	`474`	`+ else if (result.Type is { Name: "Memory" or "ReadOnlyMemory", ContainingNamespace.Name: "System" })`
	`475`	`+ {`
	`476`	`+ wrappedExpression = Wrap(nameof(__CSharpRepl_RuntimeHelper.HandleMemoryOutput), result.Expression);`
	`477`	`+ }`
	`478`	`+ else if (result.Type.IsRefLikeType)`
`476`	`479`	`{`
`477`	`480`	`var toStringMethod = result.Type`
`478`	`481`	`.GetMembers(nameof(ToString))`
`@@ -484,22 +487,26 @@ private async Task<string> InterceptInputWhenRefStructReturnNeedsToBeHandled(str`
`484`	`487`	`{`
`485`	`488`	`expressionToBeWrapped = SyntaxFactory.InvocationExpression(`
`486`	`489`	`SyntaxFactory.MemberAccessExpression(`
`487`		`- SyntaxKind.SimpleMemberAccessExpression,`
`488`		`- expressionToBeWrapped,`
	`490`	`+ SyntaxKind.SimpleMemberAccessExpression,`
	`491`	`+ expressionToBeWrapped,`
`489`	`492`	`SyntaxFactory.IdentifierName(nameof(ToString))));`
`490`	`493`	`}`
`491`	`494`	`else`
`492`	`495`	`{`
`493`	`496`	`expressionToBeWrapped = SyntaxFactory.LiteralExpression(`
`494`		`- SyntaxKind.StringLiteralExpression,`
	`497`	`+ SyntaxKind.StringLiteralExpression,`
`495`	`498`	`SyntaxFactory.Literal($"Cannot output a value of '{result.Type.Name}' because it's a ref-struct. It has to override ToString() to see its value."));`
`496`	`499`	`}`
`497`	`500`	`wrappedExpression = Wrap(`
`498`	`501`	`nameof(__CSharpRepl_RuntimeHelper.HandleRefStructOutput),`
`499`	`502`	`expressionToBeWrapped);`
`500`	`503`	`}`
`501`		`- root = root.ReplaceNode(result.Expression, wrappedExpression);`
`502`		`- return root.GetText().ToString();`
	`504`	`+`
	`505`	`+ if (result.Expression != wrappedExpression)`
	`506`	`+ {`
	`507`	`+ root = root.ReplaceNode(result.Expression, wrappedExpression);`
	`508`	`+ return root.GetText().ToString();`
	`509`	`+ }`
`503`	`510`	`}`
`504`	`511`	`return input;`
`505`	`512`
`@@ -515,4 +522,4 @@ static ExpressionSyntax Wrap(string runtimeHelperMethod, ExpressionSyntax expres`
`515`	`522`	`SyntaxFactory.Argument(`
`516`	`523`	`expressionToBeWrapped))));`
`517`	`524`	`}`
`518`		`-}`
	`525`	`+}`