Fix some missing simplifications in Composition expressions. (#429)

* Fix some missing simplifications in Composition expressions.

The logic for determining whether an expression could be simplified was sometimes wrong because it ended up hitting an overridden equality operator which compared the already-simplified values.

Also fixed the test script to look at last write time when determining which is the latest build of LottieGen.exe to run. We were looking at creation time, but it turns out that when the compiler builds, it doesn't cause the creation time to be updated if the output file previously existed. Our test script could accidentally use a release build when the latest build was actually a debug build, resulting in the test running on an old build.

* Replace the IsAtomic bool with a more generalized Precedence concept.

Without this, it was getting unwieldy to handle all the cases of precedence. Now we're removing parentheses more aggressively, so the expressions will be more efficient to parse.

* Eliminate some unnecessary whitespace in Min and Max expression functions.

Author: Simeon

source/WinCompData/Expressions/Boolean.cs

@@ -31,8 +31,7 @@ public Asserted(string text)
                 _text = text;
             }
 
-            /// <inheritdoc/>
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
 
             /// <inheritdoc/>
             // We don't actually know the operation count because the text could
@@ -78,9 +77,9 @@ protected override Boolean Simplify()
                     return new Literal(literalLeft.Value < literalRight.Value);
                 }
 
-                return left != Left || right != Right
-                    ? new LessThan(left, right)
-                    : this;
+                return ReferenceEquals(left, Left) && ReferenceEquals(right, Right)
+                    ? this
+                    : new LessThan(left, right);
             }
 
             /// <inheritdoc/>
@@ -97,8 +96,7 @@ public Literal(bool value)
                 Value = value;
             }
 
-            /// <inheritdoc/>
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
 
             /// <inheritdoc/>
             public override int OperationsCount => 0;

source/WinCompData/Expressions/Color.cs

@@ -25,8 +25,7 @@ public Asserted(string text)
                 _text = text;
             }
 
-            /// <inheritdoc/>
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
 
             /// <inheritdoc/>
             // We don't actually know the operation count because the text could
@@ -58,8 +57,7 @@ public Constructed(Scalar r, Scalar g, Scalar b, Scalar a)
 
             public Scalar A { get; }
 
-            /// <inheritdoc/>
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
 
             /// <inheritdoc/>
             public override int OperationsCount => R.OperationsCount + G.OperationsCount + B.OperationsCount + A.OperationsCount;
@@ -72,9 +70,13 @@ protected override Color Simplify()
                 var b = B.Simplified;
                 var a = A.Simplified;
 
-                return r != R || g != G || b != B || a != A
-                            ? new Constructed(r, g, b, a)
-                            : this;
+                return
+                    ReferenceEquals(r, R) &&
+                    ReferenceEquals(g, G) &&
+                    ReferenceEquals(b, B) &&
+                    ReferenceEquals(a, A)
+                        ? this
+                        : new Constructed(r, g, b, a);
             }
 
             /// <inheritdoc/>

source/WinCompData/Expressions/Expression.cs

@@ -71,10 +71,11 @@ private protected Expression()
         public abstract string ToText();
 
         /// <summary>
-        /// Gets a value indicating whether the string form of the expression can be unambigiously
-        /// parsed without parentheses.
+        /// Gets a value indicating the relative precedence of the string form of the expression.
+        /// This is used to determine whether parentheses are necessary in order to
+        /// override the left-to-right evaluation of the parent expression.
         /// </summary>
-        protected virtual bool IsAtomic => false;
+        internal virtual Precedence Precedence => Precedence.Unknown;
 
         /// <summary>
         /// The number of operations in this <see cref="Expression"/>. An operation is something that
@@ -83,7 +84,7 @@ private protected Expression()
         public abstract int OperationsCount { get; }
 
         protected static string Parenthesize(Expression expression)
-            => expression.IsAtomic
+            => expression.Precedence == Precedence.Atomic
                 ? expression.ToText()
                 : $"({expression.ToText()})";
 

source/WinCompData/Expressions/Matrix3x2.cs

@@ -57,8 +57,7 @@ internal Asserted(string text)
                 _text = text;
             }
 
-            /// <inheritdoc/>
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
 
             /// <inheritdoc/>
             // We don't actually know the operation count because the text could
@@ -108,18 +107,18 @@ protected override Matrix3x2 Simplify()
                 var m32 = _32.Simplified;
 
                 return
-                    m11 != _11 || m12 != _12 ||
-                    m21 != _21 || m22 != _22 ||
-                    m31 != _31 || m32 != _32
-                        ? new Constructed(m11, m12, m21, m22, m31, m32)
-                        : this;
+                    ReferenceEquals(m11, _11) && ReferenceEquals(m12, _12) &&
+                    ReferenceEquals(m21, _21) && ReferenceEquals(m22, _22) &&
+                    ReferenceEquals(m31, _31) && ReferenceEquals(m32, _32)
+                        ? this
+                        : new Constructed(m11, m12, m21, m22, m31, m32);
             }
 
             /// <inheritdoc/>
             protected override string CreateExpressionText()
                 => $"Matrix3x2({Parenthesize(_11)},{Parenthesize(_12)},{Parenthesize(_21)},{Parenthesize(_22)},{Parenthesize(_31)},{Parenthesize(_32)})";
 
-            protected override bool IsAtomic => true;
+            internal override Precedence Precedence => Precedence.Atomic;
         }
 
         Scalar Channel(string channelName) => Expressions.Scalar.Channel(this, channelName);

source/WinCompData/Expressions/Precedence.cs

@@ -0,0 +1,21 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace Microsoft.Toolkit.Uwp.UI.Lottie.WinCompData.Expressions
+{
+    /// <summary>
+    /// Determines the relative precedence of an operation in the string
+    /// form of an expression. For example, multiplication has higher
+    /// precedence than addition.
+    /// </summary>
+    enum Precedence : uint
+    {
+        Unknown = 0,
+        Subtraction,
+        Addition,
+        Multiplication,
+        Division,
+        Atomic,
+    }
+}