Method FindLastExpressionInLoopForAutoAtomic

syntax/tree.go:934–961

Recurs into the last expression of a loop node, looking to see if it can find a node that could be made atomic _assuming_ the conditions exist for it with the loop's ancestors. Returns The found node that should be explored further for auto-atomicity; null if it doesn't exist.

()

// that could be made atomic _assuming_ the conditions exist for it with the loop's ancestors.
// Returns The found node that should be explored further for auto-atomicity; null if it doesn't exist.
func (n *RegexNode) FindLastExpressionInLoopForAutoAtomic() *RegexNode {
	node := n

	// Start by looking at the loop's sole child.
	node = node.Children[0]

	// Skip past captures.
	for node.T == NtCapture {
		node = node.Children[0]
	}

	// If the loop's body is a concatenate, we can skip to its last child iff that
	// last child doesn't conflict with the first child, since this whole concatenation
	// could be repeated, such that the first node ends up following the last.  For
	// example, in the expression (a+[def])*, the last child is [def] and the first is
	// a+, which can't possibly overlap with [def].  In contrast, if we had (a+[ade])*,
	// [ade] could potentially match the starting 'a'.
	if node.T == NtConcatenate {
		concatCount := len(node.Children)
		lastConcatChild := node.Children[concatCount-1]
		if lastConcatChild.canBeMadeAtomic(node.Children[0], false, false) {
			return lastConcatChild
		}
	}

	// Otherwise, the loop has nothing that can participate in auto-atomicity.
	return nil
}

// Determines whether a node can be switched to an atomic loop.
//