Validate C# DefineConstants input

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Debug/KeyValuePairListEncoding.cs

@@ -4,14 +4,14 @@ namespace Microsoft.VisualStudio.ProjectSystem.Debug;
 
 internal static class KeyValuePairListEncoding
 {
-    public static IEnumerable<(string Name, string Value)> Parse(string input)
+    public static IEnumerable<(string Name, string Value)> Parse(string input, char separator = ',')
     {
         if (string.IsNullOrWhiteSpace(input))
         {
             yield break;
         }
 
-        foreach (var entry in ReadEntries(input))
+        foreach (var entry in ReadEntries(input, separator))
         {
             var (entryKey, entryValue) = SplitEntry(entry);
             var decodedEntryKey = Decode(entryKey);
@@ -23,13 +23,13 @@ internal static class KeyValuePairListEncoding
             }
         }
 
-        static IEnumerable<string> ReadEntries(string rawText)
+        static IEnumerable<string> ReadEntries(string rawText, char separator)
         {
             bool escaped = false;
             int entryStart = 0;
             for (int i = 0; i < rawText.Length; i++)
             {
-                if (rawText[i] == ',' && !escaped)
+                if (separator == rawText[i] && !escaped)
                 {
                     yield return rawText.Substring(entryStart, i - entryStart);
                     entryStart = i + 1;
@@ -67,7 +67,7 @@ static IEnumerable<string> ReadEntries(string rawText)
                 }
             }
 
-            return (string.Empty, string.Empty);
+            return (entry, string.Empty);
         }
 
         static string Decode(string value)
@@ -76,12 +76,13 @@ static string Decode(string value)
         }
     }
 
-    public static string Format(IEnumerable<(string Name, string Value)> pairs)
+    public static string Format(IEnumerable<(string Name, string Value)> pairs, string separator = ",")
     {
         // Copied from ActiveLaunchProfileEnvironmentVariableValueProvider in the .NET Project System.
         // In future, EnvironmentVariablesNameValueListEncoding should be exported from that code base and imported here.
-
-        return string.Join(",", pairs.Select(kvp => $"{Encode(kvp.Name)}={Encode(kvp.Value)}"));
+        return string.Join(separator, pairs.Select(kvp => string.IsNullOrEmpty(kvp.Value) 
+            ? Encode(kvp.Name) 
+            : $"{Encode(kvp.Name)}={Encode(kvp.Value)}"));
 
         static string Encode(string value)
         {

src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/Properties/InterceptedProjectProperties/BuildPropertyPage/DefineConstantsCSharpValueProvider.cs

@@ -40,7 +40,7 @@ public override async Task<string> OnGetUnevaluatedPropertyValueAsync(string pro
 
         return KeyValuePairListEncoding.Format(
             ParseDefinedConstantsFromUnevaluatedValue(unevaluatedDefineConstantsValue)
-                .Select(symbol => (Key: symbol, Value: bool.FalseString))
+                .Select(symbol => (symbol, bool.FalseString))
         );
     }
 
@@ -76,9 +76,18 @@ public override async Task<bool> IsValueDefinedInContextAsync(string propertyNam
         IEnumerable<string> innerConstants =
             ParseDefinedConstantsFromUnevaluatedValue(await defaultProperties.GetUnevaluatedPropertyValueAsync(ConfiguredBrowseObject.DefineConstantsProperty) ?? string.Empty);
 
-        IEnumerable<string> constantsToWrite = KeyValuePairListEncoding.Parse(unevaluatedPropertyValue)
+        // we receive a comma-separated list, we should convert it to a semicolon-separated list
+        // because each item may have multiple values separated by semicolons
+        // ie "A,B;C" should be converted to "A;B;C"
+        unevaluatedPropertyValue = KeyValuePairListEncoding.Format(
+            KeyValuePairListEncoding.Parse(unevaluatedPropertyValue, separator: ','),
+            separator: ";");
+
+        IEnumerable<string> constantsToWrite = KeyValuePairListEncoding.Parse(unevaluatedPropertyValue, separator: ';')
             .Select(pair => pair.Name)
-            .Where(x => !innerConstants.Contains(x))
+            .Select(constant => constant.Trim(';')) // trim any leading or trailing semicolons, because we will add our own separating semicolons
+            .Where(constant => !innerConstants.Contains(constant))
+            .Where(constant => !string.IsNullOrEmpty(constant)) // you aren't allowed to add a semicolon as a constant
             .Distinct()
             .ToList();
 

tests/Microsoft.VisualStudio.ProjectSystem.Managed.VS.UnitTests/ProjectSystem/VS/Properties/KeyValuePairListEncodingTests.cs

@@ -0,0 +1,47 @@
+// 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.md file in the project root for more information.
+
+using Microsoft.VisualStudio.ProjectSystem.Debug;
+
+namespace Microsoft.VisualStudio.ProjectSystem.VS.Properties;
+
+public class KeyValuePairListEncodingTests
+{
+    [Theory]
+    [InlineData("key1=value1;key2=value2", new[] { "key1", "value1", "key2", "value2" })]
+    [InlineData("key1=value1;;key2=value2", new[] { "key1", "value1", "key2", "value2" })]
+    [InlineData("key1=value1;;;key2=value2", new[] { "key1", "value1", "key2", "value2" })]
+    [InlineData("key1=value1;key2=value2;key3=value3", new[] { "key1", "value1", "key2", "value2", "key3", "value3" })]
+    [InlineData("key1;key2=value2", new[] { "key1", "", "key2", "value2" })]
+    [InlineData("key1;key2;key3=value3", new[] { "key1", "", "key2", "", "key3", "value3" })]
+    [InlineData("key1;;;key3;;", new[] { "key1", "", "key3", "" })]
+    public void Parse_ValidInput_ReturnsExpectedPairs(string input, string[] expectedPairs)
+    {
+        var result = KeyValuePairListEncoding.Parse(input, ';').SelectMany(pair => new[] { pair.Name, pair.Value }).ToArray();
+        Assert.Equal(expectedPairs, result);
+    }
+
+    [Theory]
+    [InlineData(new[] { "key1", "value1", "key2", "value2" }, "key1=value1;key2=value2")]
+    [InlineData(new[] { "key1", "value1", "key2", "value2", "key3", "value3" }, "key1=value1;key2=value2;key3=value3")]
+    [InlineData(new[] { "key1", "", "key2", "value2" }, "key1;key2=value2")]
+    [InlineData(new[] { "key1", "", "key2", "", "key3", "value3" }, "key1;key2;key3=value3")]
+    public void Format_ValidPairs_ReturnsExpectedString(string[] pairs, string expectedString)
+    {
+        var nameValuePairs = ToNameValues(pairs);
+        var result = KeyValuePairListEncoding.Format(nameValuePairs, ";");
+        Assert.Equal(expectedString, result);
+        return;
+
+        static IEnumerable<(string Name, string Value)> ToNameValues(IEnumerable<string> pairs)
+        {
+            using var e = pairs.GetEnumerator();
+            while (e.MoveNext())
+            {
+                var name = e.Current;
+                Assert.True(e.MoveNext());
+                var value = e.Current;
+                yield return (name, value);
+            }
+        }
+    }
+}