Fix perf issue in LineTrackingStringbuffer.ScanLines.

I noticed several hundred ms spent in this method from a customer profile. Primarilly, the method was doing a linear scan of all lines trying to find one that contained the requested position. I changed this to a binary search, but kept/improved the optimization around checking next/previous lines before instigating the search.

Note, there was also a bug where the old code did:

else if (absoluteIndex > _currentLine.Index && _currentLine.Index + 1 < _lines.Count)

but it should have been coparing absoluteIndex with _currentLine.Start
\n\nCommit migrated from dotnet/razor@32a0f28

Author: ToddGrun

src/Razor/Microsoft.AspNetCore.Razor.Language/src/Legacy/LineTrackingStringBuffer.cs

@@ -82,44 +82,83 @@ private TextLine FindLine(int absoluteIndex)
         {
             TextLine selected = null;
 
-            if (_currentLine != null)
+            if (_currentLine == null)
             {
-                if (_currentLine.Contains(absoluteIndex))
+                // Scan from line 0
+                selected = ScanLines(absoluteIndex, 0, _lines.Count);
+            }
+            else if (absoluteIndex >= _currentLine.End)
+            {
+                if (_currentLine.Index + 1 < _lines.Count)
                 {
-                    // This index is on the last read line
-                    selected = _currentLine;
+                    // This index is after the last read line
+                    var nextLine = _lines[_currentLine.Index + 1];
+
+                    // Optimization to not search if it's the common case where the line after _currentLine is being requested.
+                    if (nextLine.Contains(absoluteIndex))
+                    {
+                        selected = nextLine;
+                    }
+                    else
+                    {
+                        selected = ScanLines(absoluteIndex, _currentLine.Index, _lines.Count);
+                    }
                 }
-                else if (absoluteIndex > _currentLine.Index && _currentLine.Index + 1 < _lines.Count)
+            }
+            else if (absoluteIndex < _currentLine.Start)
+            {
+                if (_currentLine.Index > 0)
                 {
-                    // This index is ahead of the last read line
-                    selected = ScanLines(absoluteIndex, _currentLine.Index);
+                    // This index is before the last read line
+                    var prevLine = _lines[_currentLine.Index - 1];
+
+                    // Optimization to not search if it's the common case where the line before _currentLine is being requested.
+                    if (prevLine.Contains(absoluteIndex))
+                    {
+                        selected = prevLine;
+                    }
+                    else
+                    {
+                        selected = ScanLines(absoluteIndex, 0, _currentLine.Index);
+                    }
                 }
             }
-
-            // Have we found a line yet?
-            if (selected == null)
+            else
             {
-                // Scan from line 0
-                selected = ScanLines(absoluteIndex, 0);
+                // This index is on the last read line
+                selected = _currentLine;
             }
 
             Debug.Assert(selected == null || selected.Contains(absoluteIndex));
             _currentLine = selected;
             return selected;
         }
 
-        private TextLine ScanLines(int absoluteIndex, int startPos)
+        private TextLine ScanLines(int absoluteIndex, int startLineIndex, int endLineIndex)
         {
-            for (int i = 0; i < _lines.Count; i++)
+            // binary search for the line containing absoluteIndex
+            var lowIndex = startLineIndex;
+            var highIndex = _lines.Count;
+
+            while (lowIndex != highIndex)
             {
-                var idx = (i + startPos) % _lines.Count;
-                Debug.Assert(idx >= 0 && idx < _lines.Count);
+                var midIndex = (lowIndex + highIndex) / 2;
+                var midLine = _lines[midIndex];
 
-                if (_lines[idx].Contains(absoluteIndex))
+                if (absoluteIndex >= midLine.End)
+                {
+                    lowIndex = midIndex + 1;
+                }
+                else if (absoluteIndex < midLine.Start)
                 {
-                    return _lines[idx];
+                    highIndex = midIndex;
+                }
+                else
+                {
+                    return midLine;
                 }
             }
+
             return null;
         }