Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries by olsaarik · Pull Request #74525 · dotnet/runtime

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik · 2022-08-24T21:08:27Z

This PR adds a test for and fixes#74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

ghost · 2022-08-24T21:08:46Z

Tagging subscribers to this area: @dotnet/area-system-text-regularexpressions
See info in area-owners.md if you want to be subscribed.

Issue Details

This PR adds a test for and fixes #74467.

The test is the more complicated part, as it needs to find how many characters the innermost matching loop is processing at a time. Since that value is not public it first does a binary search over different input lengths with a 1-tick timeout to find the minimum input length to trigger the timeout. Then with that a pattern of ^a*$ needs to not match an input of form "aaa...ab" where there are exactly enough a's to pop out of the loop right before the b.

Including the test in the unit test project would have been another option, but the matcher's sources aren't built into that currently.

The fix itself is quite simple, with an integer bound passed in instead of slicing the input (since the slice length is used to indicate where the whole input ends for anchors).

Author:	olsaarik
Assignees:	-
Labels:	`area-System.Text.RegularExpressions`
Milestone:	-

stephentoub · 2022-08-28T14:56:43Z

I'm missing where exactly the problem is. To save me the trouble of debugging, can you point me to where it is and why passing in the length separately rather than slicing fixes it?

joperezr · 2022-08-29T14:20:22Z


 // If there is more input available try to transition with the next character.
- if (!IsMintermId(positionId) || !TStateHandler.TryTakeTransition(this, ref state, positionId))
+ if (pos >= length || !TStateHandler.TryTakeTransition(this, ref state, positionId))


So if I understood correctly the bug was here where we were not checking if we are at the end of the input, right? I'm still not understanding why the problem is only happening for anchors

The problem was specifically with end anchors, as they rely on the position ID of the next character being -1 exactly when it is the end of the whole input. When they inadvertently matched, they would cause the whole search to end prematurely instead of the outer loop just checking the timeout and going back in for more input.

stephentoub · 2022-08-28T14:46:39Z

+ return 1;
+ }
+ }
+ int charsPerTimeoutCheck = Array.BinarySearch(Enumerable.Range(0, 16_000).ToArray(), -1, Comparer<int>.Create(IsCharsPerTimeoutCheck));


This doesn't seem sound. BinarySearch expects a consistent comparer, but this comparer can change answer from call to call.

Can we just use your test from the issue?

I'll simplify the test by hardcoding the charsPerTimeoutCheck and including asserts that validate it's indeed the right value before the actual test.

I simplified the test even further, now there's just a constant that has to be large enough to trigger timeout checks. I realized it doesn't have to be exact for the test pattern ^a*$, as treating a timeout check in any point of a string "aaaaaaa...aaab" as an end-of-input would cause a match. I verified that the test indeed does fail if I reintroduce the slicing.

stephentoub · 2022-09-06T14:55:01Z

@olsaarik, where are we with this? I assume it's important this make it into .NET 7.

olsaarik · 2022-09-08T16:11:21Z

@stephentoub The source of the bug was an interaction with the two (uint)pos >= (uint)input.Length checks in the IInputReader implementations here:

runtime/src/libraries/System.Text.RegularExpressions/src/System/Text/RegularExpressions/Symbolic/SymbolicRegexMatcher.cs

Lines 1218 to 1239 in 8a3a702

privatereadonlystructNoZAnchorInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)=>
(uint)pos>=(uint)input.Length?-1:matcher._mintermClassifier.GetMintermID(input[pos]);
}
/// <summary>This reader includes full handling of an \n as the last character of input for the \Z anchor.</summary>
privatereadonlystructFullInputReader:IInputReader
{
publicstaticintGetPositionId(SymbolicRegexMatcher<TSet>matcher,ReadOnlySpan<char>input,intpos)
{
if((uint)pos>=(uint)input.Length)
return-1;
intc=input[pos];
// Find the minterm, handling the special case for the last \n for states that start with a relevant anchor
returnc=='\n'&&pos==input.Length-1?
matcher._minterms.Length:// mintermId = minterms.Length represents an \n at the very end of input
matcher._mintermClassifier.GetMintermID(c);
}
}

Anchors sensitive to the end-of-input use the -1 position ID coming out of that check to decide that they match.

olsaarik · 2022-09-08T20:25:44Z

If the simplified test looks good I think this PR should be good to merge as soon as the tests pass. I reran that failing test, which was due to something unrelated to regex.

stephentoub

Thanks!

stephentoub · 2022-09-08T22:04:11Z

/backport to release/7.0

github-actions · 2022-09-08T22:04:24Z

Started backporting to release/7.0: https://github.com/dotnet/runtime/actions/runs/3018567091

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

olsaarik added 5 commits August 24, 2022 13:36

Test for exposing timeout check bug
fab6701

Fix timeout check bug
6f7c0b3

Improve naming
56959d1

Simplify test
db627c0

Make test search range higher
8a3a702

olsaarik requested review from joperezr and stephentoub August 24, 2022 21:08

ghost added the area-System.Text.RegularExpressions label Aug 24, 2022

ghost assigned olsaarik Aug 24, 2022

olsaarik mentioned this pull request Aug 24, 2022
More timeout checks in RegexOptions.NonBacktracking #74531
Closed

joperezr reviewed Aug 29, 2022
View reviewed changes

stephentoub reviewed Sep 1, 2022
View reviewed changes

stephentoub added this to the 7.0.0 milestone Sep 6, 2022

Simplify test for timeout check bug
8fb04b9

stephentoub approved these changes Sep 8, 2022
View reviewed changes

olsaarik merged commit 239f550 into dotnet:mainSep 8, 2022

olsaarik deleted the nonbacktracking-timeout-anchors-fix branch September 8, 2022 22:00

github-actionsBot mentioned this pull request Sep 8, 2022
[release/7.0] Fix RegexOptions.NonBacktracking matching end anchors at timeout check boundaries #75308
Merged

EgorBo mentioned this pull request Sep 13, 2022
Regressions in System.Text.RegularExpressions.Tests.Perf_Regex_Industry_* #75549
Closed

ghost locked as resolved and limited conversation to collaborators Oct 9, 2022

Uh oh!

Conversation

olsaarik commented Aug 24, 2022

Uh oh!

ghost commented Aug 24, 2022

Uh oh!

stephentoub commented Aug 28, 2022• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

stephentoub commented Sep 6, 2022

Uh oh!

olsaarik commented Sep 8, 2022

Uh oh!

olsaarik commented Sep 8, 2022

Uh oh!

stephentoub left a comment

Choose a reason for hiding this comment

Uh oh!

stephentoub commented Sep 8, 2022

Uh oh!

github-actionsBot commented Sep 8, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

Uh oh!

Conversation

olsaarik commented Aug 24, 2022

Uh oh!

ghost commented Aug 24, 2022

Uh oh!

stephentoub commented Aug 28, 2022• edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

stephentoub commented Sep 6, 2022

Uh oh!

olsaarik commented Sep 8, 2022

Uh oh!

olsaarik commented Sep 8, 2022

Uh oh!

stephentoub left a comment

Choose a reason for hiding this comment

Uh oh!

stephentoub commented Sep 8, 2022

Uh oh!

github-actionsBot commented Sep 8, 2022

Uh oh!

Reviewers

Assignees

Labels

Projects

stephentoub commented Aug 28, 2022•
edited
Loading

stephentoub commented Aug 28, 2022•
edited
Loading

stephentoub commented Aug 28, 2022•
edited
Loading