Releases/3.2-Package

* Expression type tweak * Defaulting more ExpressionTypes to indicate a non-captured value ina MemberAccess, re: #101 * Handling fonts which the Font object cannot support, re: #102 * Test coverage for issue #103 * Support for translating ValueTuples * Updating package to v3.2 * Tidying * Fixing handling of reused ParameterExpression objects across different scopes * v3.2 Nuget package * Updating release notes * Updating copyright year

Author: SteveWilkes

Directory.Build.props

@@ -5,7 +5,7 @@
 <Company>AgileObjects Ltd</Company>
 <Product>AgileObjects.ReadableExpressions</Product>
 <Authors>Steve Wilkes</Authors>
-<Copyright>Copyright © AgileObjects Ltd 2021</Copyright>
+<Copyright>Copyright © AgileObjects Ltd 2022</Copyright>
 <NeutralResourcesLanguage>en</NeutralResourcesLanguage>
 <RepositoryType>git</RepositoryType>
 <RepositoryUrl>https://.com/AgileObjects/ReadableExpressions</RepositoryUrl>

NuGet/AgileObjects.ReadableExpressions.3.2.0.nupkg

@@ -15,6 +15,10 @@
 <IsPackable>false</IsPackable>
 </PropertyGroup>
 
+<PropertyGroup>
+<DefineConstants>$(DefineConstants);TRACE;FEATURE_VALUE_TUPLE</DefineConstants>
+</PropertyGroup>
+
 <ItemGroup>
 <Compile Include="..\ClsCompliant.cs">
 <Link>Properties\ClsCompliant.cs</Link>

NuGet/AgileObjects.ReadableExpressions.3.2.0.snupkg

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using Common;
+using NetStandardPolyfills;
 using ReadableExpressions.Extensions;
 #if !NET35
 using Xunit;
@@ -55,7 +56,7 @@ public void ShouldNameAnAnonymousTypeWithAConfiguredNameFactory()
 {
 var anon = new { One = 1, Two = "two" };
 
-var friendlyName = anon.GetType().GetFriendlyName(c => c.NameAnonymousTypesUsing(t => "object"));
+var friendlyName = anon.GetType().GetFriendlyName(c => c.NameAnonymousTypesUsing(_ => "object"));
 
 friendlyName.ShouldBe("object");
 }
@@ -140,7 +141,7 @@ public void ShouldNameGenericGenericTypeArguments()
 public void ShouldNamePartClosedGenericTypeArrays()
 {
 var name = typeof(GenericTestHelper<>)
-.GetField("Keys").FieldType
+.GetPublicInstanceField("Keys").FieldType
 .GetFriendlyName();
 
 name.ShouldBe("KeyValuePair<T, int>[]");

ReadableExpressions.UnitTests.NetCore3.1/ReadableExpressions.UnitTests.NetCore3.1.csproj

@@ -10,7 +10,7 @@
 </PropertyGroup>
 
 <PropertyGroup>
-<DefineConstants>$(DefineConstants);TRACE;FEATURE_EF;FEATURE_PARTIAL_TRUST;FEATURE_DYNAMIC;FEATURE_HTML</DefineConstants>
+<DefineConstants>$(DefineConstants);TRACE;FEATURE_EF;FEATURE_PARTIAL_TRUST;FEATURE_DYNAMIC;FEATURE_VALUE_TUPLE;FEATURE_HTML</DefineConstants>
 </PropertyGroup>
 
 <ItemGroup>

ReadableExpressions.UnitTests/Extensions/WhenGettingFriendlyTypeNames.cs

@@ -487,6 +487,35 @@ public void ShouldVarAssignAVariableUsedInNestedConstructs()
 translated.ShouldBe(EXPECTED.TrimStart());
 }
 
+[Fact]
+public void ShouldVarAssignAVariableReusedInASiblingBlock()
+{
+var intVariable = Variable(typeof(int), "i");
+var assignVariable1 = Assign(intVariable, Constant(1));
+var assignmentBlock = Block(new[] { intVariable }, assignVariable1);
+
+var assignVariable2 = Assign(intVariable, Constant(2));
+var assignment2Block = Block(new[] { intVariable }, assignVariable2);
+
+var assign1Or2 = IfThenElse(
+Constant(true),
+assignmentBlock,
+assignment2Block);
+
+var translated = assign1Or2.ToReadableString();
+
+const string EXPECTED = @"
+if (true)
+{
+var i = 1;
+}
+else
+{
+var i = 2;
+}";
+translated.ShouldBe(EXPECTED.TrimStart());
+}
+
 [Fact]
 public void ShouldNotIndentParamsArrayArguments()
 {
@@ -620,10 +649,10 @@ public void ShouldNotRemoveParenthesesFromALambdaInvokeResultAssignment()
 public void ShouldNotIndentSingleArgumentBlockParameters()
 {
 var writeString = CreateLambda(() => Console.WriteLine("String!")).Body;
-
+
 var stringsBlock = Block(
-writeString,
-writeString,
+writeString,
+writeString,
 writeString,
 Constant("All done!"));
 

ReadableExpressions.UnitTests/ReadableExpressions.UnitTests.csproj

@@ -2,6 +2,7 @@
 namespace AgileObjects.ReadableExpressions.UnitTests
 {
 using System;
+using System.Dynamic;
 using System.Globalization;
 using Common;
 using Microsoft.CSharp.RuntimeBinder;
@@ -10,29 +11,37 @@ namespace AgileObjects.ReadableExpressions.UnitTests
 
 public class WhenTranslatingDynamicOperations : TestClassBase
 {
+// See https://.com/agileobjects/ReadableExpressions/issues/103
 [Fact]
 public void ShouldTranslateAPropertyReadAccess()
 {
-var lengthGetterSiteBinder = Binder.GetMember(
+var dynamicNullableIntGetterSiteBinder = Binder.GetMember(
 CSharpBinderFlags.None,
-"Length",
-typeof(WhenTranslatingDynamicOperations),
+"NullableInt",
+typeof(object),
 new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
 
-var dynamicParameter = Parameter(typeof(object), "obj");
+var expandoParameter = Parameter(typeof(ExpandoObject));
 
-var dynamicLengthGetter = Dynamic(
-lengthGetterSiteBinder,
+var dynamicNullableIntGetter = Dynamic(
+dynamicNullableIntGetterSiteBinder,
 typeof(object),
-dynamicParameter);
+expandoParameter);
+
+var convertedDynamicNullableInt =
+Convert(dynamicNullableIntGetter, typeof(int?));
+
+var hasValueAccess = Property(convertedDynamicNullableInt, "HasValue");
 
-var dynamicLengthLambda = Lambda<Func<object, object>>(dynamicLengthGetter, dynamicParameter);
+var dynamicNullableIntHasValueLambda =
+Lambda<Func<ExpandoObject, bool>>(hasValueAccess, expandoParameter);
 
-dynamicLengthLambda.Compile();
+dynamicNullableIntHasValueLambda.Compile();
 
-var translated = dynamicLengthLambda.ToReadableString();
+var translated = dynamicNullableIntHasValueLambda.ToReadableString();
 
-translated.ShouldBe("obj => obj.Length");
+translated.ShouldBe(
+"expandoObject => ((int?)expandoObject.NullableInt).HasValue");
 }
 
 [Fact]

ReadableExpressions.UnitTests/WhenFormattingCode.cs

@@ -60,8 +60,13 @@ public void ShouldAnalyseACustomAnalysableExpression()
 
 var analysis = ExpressionAnalysis.For(container, new TestTranslationSettings());
 
-analysis.ShouldBeDeclaredInVariableList(intVariable1, variable1Block).ShouldBeFalse();
-analysis.ShouldBeDeclaredInVariableList(intVariable2, variable2Block).ShouldBeFalse();
+analysis.EnterScope(variable1Block);
+analysis.ShouldBeDeclaredInVariableList(intVariable1).ShouldBeFalse();
+analysis.ExitScope();
+
+analysis.EnterScope(variable2Block);
+analysis.ShouldBeDeclaredInVariableList(intVariable2).ShouldBeFalse();
+analysis.ExitScope();
 }
 
 #region Helper Members

ReadableExpressions.UnitTests/WhenTranslatingDynamicOperations.cs

@@ -111,7 +111,8 @@ public void ShouldTranslateQuotedLambdaWithAnAnnotation()
 
 var quotedLambda = Quote(intToDouble);
 
-var translated = quotedLambda.ToReadableString(stgs => stgs.ShowQuotedLambdaComments);
+var translated = quotedLambda.ToReadableString(stgs =>
+stgs.ShowQuotedLambdaComments);
 
 const string EXPECTED = @"
 // Quoted to induce a closure:

ReadableExpressions.UnitTests/WhenTranslatingExtensions.cs

@@ -133,6 +133,21 @@ public void ShouldTranslateAnInstanceMemberExpression()
 translated.ShouldBe("d => d.Day");
 }
 
+// See https://.com/agileobjects/ReadableExpressions/issues/101
+[Fact]
+public void ShouldTranslateAnExtensionExpressionMemberExpression()
+{
+var extension = new ExtensionExpression(typeof(PropertiesHelper));
+
+var extensionMemberAccess = Property(
+extension,
+nameof(PropertiesHelper.PublicInstance));
+
+var translated = extensionMemberAccess.ToReadableString();
+
+translated.ShouldBe($"{extension}.PublicInstance");
+}
+
 [Fact]
 public void ShouldTranslateAStaticMemberExpression()
 {
@@ -996,5 +1011,19 @@ public IEnumerator GetEnumerator()
 }
 }
 
+internal class ExtensionExpression : Expression
+{
+public ExtensionExpression(Type type)
+{
+Type = type;
+}
+
+public override string ToString() => "Extension_Expr";
+
+public override Type Type { get; }
+
+public override ExpressionType NodeType => ExpressionType.Extension;
+}
+
 #endregion
 }

ReadableExpressions.UnitTests/WhenTranslatingLambdas.cs

@@ -447,7 +447,8 @@ public void ShouldTranslateAnAnonymousTypeCreationWithACustomFactory()
 // ReSharper disable once AssignNullToNotNullAttribute
 var creation = New(constructor, Constant(10));
 
-var translated = creation.ToReadableString(stgs => stgs.NameAnonymousTypesUsing(t => "MyMagicObject"));
+var translated = creation.ToReadableString(stgs => stgs
+.NameAnonymousTypesUsing(_ => "MyMagicObject"));
 
 translated.ShouldBe("new MyMagicObject { ValueInt = 10 }");
 }
@@ -465,6 +466,33 @@ public void ShouldTranslateAFullyQualfiedAnonymousTypeCreation()
 
 translated.ShouldBe("new { Value = default(System.TimeSpan) }");
 }
+
+#if FEATURE_VALUE_TUPLE
+[Fact]
+public void ShouldTranslateAValueTupleNewExpression()
+{
+var valueTuple = (default(int), default(string));
+var valueTupleType = valueTuple.GetType();
+
+var valueTupleCtor = valueTupleType
+.GetPublicInstanceConstructor(typeof(int), typeof(string));
+
+var stringEmpty = typeof(string)
+.GetPublicStaticField(nameof(string.Empty));
+
+var newValueTuple = New(
+valueTupleCtor,
+Constant(123),
+Field(null, stringEmpty));
+
+var tupleVariable = Variable(valueTupleType);
+var assignTuple = Assign(tupleVariable, newValueTuple);
+
+var translated = assignTuple.ToReadableString();
+
+translated.ShouldBe("intStringValueTuple = (123, string.Empty)");
+}
+#endif
 }
 
 #region Helper Classes

ReadableExpressions.UnitTests/WhenTranslatingMemberAccesses.cs

@@ -36,7 +36,7 @@ public FontFamilySelector(VisualizerDialog dialog)
 
 dialog.RegisterThemeable(this);
 
-SelectedIndexChanged += (sender, args) =>
+SelectedIndexChanged += (sender, _) =>
 {
 var selector = (FontFamilySelector)sender;
 var font = (Font)selector.SelectedItem;
@@ -51,7 +51,19 @@ private static Font[] GetFonts()
 {
 return new InstalledFontCollection()
 .Families
-.Select(ff => new Font(ff, 10))
+.Select(ff =>
+{
+try
+{
+return new Font(ff, 10);
+}
+catch
+{
+// See https://.com/agileobjects/ReadableExpressions/issues/102
+return null;
+}
+})
+.Where(font => font != null)
 .ToArray();
 }