Add TarDirectory and Untar tasks for creating and extracting tar archives

documentation/specs/question.md

@@ -78,6 +78,9 @@ Error when SkipUnchangedFiles is true.
 `ZipDirectory`
 Error if the destination zip file doesn't exists.
 
+`TarDirectory`
+Error if the destination tar file doesn't exist.
+
 ## Common Error
 
 - **Typographical error**. Spelling, casing, or incorrect path.  Check if the target inputs and outputs real files.

src/Build.UnitTests/BackEnd/TaskBuilderTestTask.cs

@@ -66,6 +66,16 @@ public CustomStruct(IConvertible value)
         /// </summary>
         internal static readonly CustomStruct[] s_customStructArray = new CustomStruct[] { new CustomStruct(43), new CustomStruct(44) };
 
+        /// <summary>
+        /// An enum used to validate engine-level binding of string values to enum task parameters.
+        /// </summary>
+        public enum TestTaskEnum
+        {
+            None,
+            First,
+            Second,
+        }
+
         /// <summary>
         /// The task host.
         /// </summary>
@@ -701,6 +711,17 @@ public AbsolutePath AbsolutePathParam
             }
         }
 
+        /// <summary>
+        /// An enum parameter, used to validate engine-level binding of string values to enum task parameters.
+        /// </summary>
+        public TestTaskEnum EnumParam
+        {
+            set
+            {
+                _testTaskHost?.ParameterSet("EnumParam", value);
+            }
+        }
+
         /// <summary>
         /// An AbsolutePath array parameter.
         /// </summary>

src/Build.UnitTests/BackEnd/TaskExecutionHost_Tests.cs

@@ -700,6 +700,49 @@ public void TestSetTaskItemIntArrayParamEmptyItem()
 
         #endregion
 
+        #region Enum Params
+
+        /// <summary>
+        /// Validate that setting an enum parameter binds the string value (case-insensitively) to the enum member.
+        /// </summary>
+        [Fact]
+        public void TestSetEnumParam()
+        {
+            ValidateTaskParameter("EnumParam", "Second", TaskBuilderTestTask.TestTaskEnum.Second);
+        }
+
+        /// <summary>
+        /// Validate that enum binding is case-insensitive.
+        /// </summary>
+        [Fact]
+        public void TestSetEnumParamCaseInsensitive()
+        {
+            ValidateTaskParameter("EnumParam", "first", TaskBuilderTestTask.TestTaskEnum.First);
+        }
+
+        /// <summary>
+        /// Validate that setting the parameter with an empty value does not cause it to be set.
+        /// </summary>
+        [Fact]
+        public void TestSetEnumParamEmptyAttribute()
+        {
+            ValidateTaskParameterNotSet("EnumParam", "");
+        }
+
+        /// <summary>
+        /// Validate that setting an enum parameter to a value that does not map to a defined member is an error.
+        /// </summary>
+        [Fact]
+        public void TestSetEnumParamInvalidValue()
+        {
+            var parameters = GetStandardParametersDictionary(true);
+            parameters["EnumParam"] = ("NotADefinedValue", ElementLocation.Create("foo.proj"));
+
+            Should.Throw<InvalidProjectFileException>(() => _host.SetTaskParameters(parameters));
+        }
+
+        #endregion
+
         #region FileInfo Params
 
         /// <summary>

src/Framework/ValueTypeParser.cs

@@ -94,6 +94,19 @@ public static object Parse(string value, Type targetType)
                     return value;
                 }
 
+                // Enums bind by their (case-insensitive) member name, and values that do not map to a
+                // defined member are rejected so the engine surfaces a clear parameter-binding error.
+                if (targetType.IsEnum)
+                {
+                    object result = Enum.Parse(targetType, value, ignoreCase: true);
+                    if (!Enum.IsDefined(targetType, result))
+                    {
+                        throw new ArgumentException($"'{value}' is not a defined value of enum type {targetType.Name}.", nameof(value));
+                    }
+
+                    return result;
+                }
+
                 // Everything else (numeric types, char, etc.) is converted via Convert.ChangeType, pinned
                 // to InvariantCulture. This is deliberately permissive: a future analyzer is expected to
                 // steer authors toward the first-class supported types above and away from relying on this