Handle Perl braced hex constants (#2005)

Author: Widthdom

src/CodeIndex/Indexer/Symbols/SymbolExtractor.Perl.cs

@@ -13,7 +13,7 @@ public static partial class SymbolExtractor
         @"^\s*use\s+constant\s+\{",
         RegexOptions.Compiled | RegexOptions.CultureInvariant);
     private static readonly Regex PerlHashConstantKeyRegex = new(
-        @"(?:^|,)\s*(?:""(?<quoted>(?:\\x[0-9A-Fa-f]{2}|\\u[0-9A-Fa-f]{4}|\\.|[^""])*)""|'(?<quoted>(?:\\x[0-9A-Fa-f]{2}|\\u[0-9A-Fa-f]{4}|\\.|[^'])*)'|(?<bare>[\p{L}_][\p{L}\p{Nd}_]*))\s*=>",
+        @"(?:^|,)\s*(?:""(?<quoted>(?:\\x\{[0-9A-Fa-f]+\}|\\x[0-9A-Fa-f]{2}|\\.|[^""])*)""|'(?<quoted>(?:\\x\{[0-9A-Fa-f]+\}|\\x[0-9A-Fa-f]{2}|\\.|[^'])*)'|(?<bare>[\p{L}_][\p{L}\p{Nd}_]*))\s*=>",
         RegexOptions.Compiled | RegexOptions.CultureInvariant);
 
     private static void ExtractPerlHashConstantSymbols(long fileId, string[] lines, List<SymbolRecord> symbols)
@@ -75,17 +75,22 @@ private static string DecodePerlQuotedConstantEscapes(string value)
             }
 
             var marker = value[i + 1];
-            if (marker == 'x' && i + 3 < value.Length && TryParseHexScalar(value.AsSpan(i + 2, 2), out var hexByte))
+            if (marker == 'x'
+                && i + 3 < value.Length
+                && value[i + 2] == '{'
+                && TryFindPerlBracedHexEscapeEnd(value, i + 3, out var escapeEnd)
+                && TryParseHexScalar(value.AsSpan(i + 3, escapeEnd - (i + 3)), out var scalar)
+                && scalar <= 0x10FFFF)
             {
-                builder.Append((char)hexByte);
-                i += 3;
+                builder.Append(char.ConvertFromUtf32(scalar));
+                i = escapeEnd;
                 continue;
             }
 
-            if (marker == 'u' && i + 5 < value.Length && TryParseHexScalar(value.AsSpan(i + 2, 4), out var unicodeScalar))
+            if (marker == 'x' && i + 3 < value.Length && TryParseHexScalar(value.AsSpan(i + 2, 2), out var hexByte))
             {
-                builder.Append(char.ConvertFromUtf32(unicodeScalar));
-                i += 5;
+                builder.Append((char)hexByte);
+                i += 3;
                 continue;
             }
 
@@ -99,6 +104,21 @@ private static string DecodePerlQuotedConstantEscapes(string value)
     private static bool TryParseHexScalar(ReadOnlySpan<char> value, out int scalar)
         => int.TryParse(value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out scalar);
 
+    private static bool TryFindPerlBracedHexEscapeEnd(string value, int start, out int end)
+    {
+        for (var i = start; i < value.Length; i++)
+        {
+            if (value[i] == '}')
+            {
+                end = i;
+                return i > start;
+            }
+        }
+
+        end = -1;
+        return false;
+    }
+
     private readonly record struct PerlBodyLineSegment(int BodyStartIndex, int LineIndex, int ColumnOffset);
 
     private static bool TryCollectPerlHashConstantBody(
@@ -124,11 +144,13 @@ private static bool TryCollectPerlHashConstantBody(
             return false;
 
         var builder = new System.Text.StringBuilder();
+        var inQuotedKey = false;
+        var quotedKeyDelimiter = '\0';
         for (var lineIndex = startLineIndex; lineIndex < lines.Length; lineIndex++)
         {
             var line = lines[lineIndex];
             var segmentStart = lineIndex == startLineIndex ? openBraceIndex + 1 : 0;
-            var closeBraceIndex = line.IndexOf('}', segmentStart);
+            var closeBraceIndex = FindPerlHashConstantBlockCloseBrace(line, segmentStart, ref inQuotedKey, ref quotedKeyDelimiter);
             var segmentEnd = closeBraceIndex >= 0 ? closeBraceIndex : line.Length;
             if (segmentEnd > segmentStart)
             {
@@ -149,6 +171,45 @@ private static bool TryCollectPerlHashConstantBody(
         return false;
     }
 
+    private static int FindPerlHashConstantBlockCloseBrace(
+        string line,
+        int start,
+        ref bool inQuotedKey,
+        ref char quotedKeyDelimiter)
+    {
+        for (var i = start; i < line.Length; i++)
+        {
+            if (inQuotedKey)
+            {
+                if (line[i] == '\\' && i + 1 < line.Length)
+                {
+                    i++;
+                    continue;
+                }
+
+                if (line[i] == quotedKeyDelimiter)
+                {
+                    inQuotedKey = false;
+                    quotedKeyDelimiter = '\0';
+                }
+
+                continue;
+            }
+
+            if (line[i] == '"' || line[i] == '\'')
+            {
+                inQuotedKey = true;
+                quotedKeyDelimiter = line[i];
+                continue;
+            }
+
+            if (line[i] == '}')
+                return i;
+        }
+
+        return -1;
+    }
+
     private static (int LineIndex, int Column) ResolvePerlHashConstantBodyPosition(
         IReadOnlyList<PerlBodyLineSegment> lineSegments,
         int bodyIndex)

tests/CodeIndex.Tests/SymbolExtractorTests.cs

@@ -25305,19 +25305,22 @@ use constant {
                 "foo " => 1,
                 foo => 2,
                 "naïve" => 3,
-                "nai\u0308ve" => 4,
+                "naïve" => 4,
                 "hex\xEF" => 5,
                 "hexï" => 6,
-                "   " => 7,
+                "braced\x{00EF}" => 7,
+                "bracedï" => 8,
+                "   " => 9,
             };
             """;
 
         var symbols = SymbolExtractor.Extract(1, "perl", content);
 
-        Assert.Equal(3, symbols.Count(symbol => symbol.Kind == "function"));
+        Assert.Equal(4, symbols.Count(symbol => symbol.Kind == "function"));
         Assert.Single(symbols.Where(symbol => symbol.Kind == "function" && symbol.Name == "foo"));
         Assert.Single(symbols.Where(symbol => symbol.Kind == "function" && symbol.Name == "naïve"));
         Assert.Single(symbols.Where(symbol => symbol.Kind == "function" && symbol.Name == "hexï"));
+        Assert.Single(symbols.Where(symbol => symbol.Kind == "function" && symbol.Name == "bracedï"));
         Assert.DoesNotContain(symbols, symbol => symbol.Name == "foo ");
     }