Fixed setting of lastIndex after String.replace() and String.match(). Closes #682

builtin_regexp.go

@@ -2,11 +2,12 @@ package goja
 
 import (
 	"fmt"
-	"github.com/dop251/goja/parser"
 	"regexp"
 	"strings"
 	"unicode/utf16"
 	"unicode/utf8"
+
+	"github.com/dop251/goja/parser"
 )
 
 func (r *Runtime) newRegexpObject(proto *Object) *regexpObject {
@@ -762,16 +763,15 @@ func (r *Runtime) regexpproto_stdMatcher(call FunctionCall) Value {
 		return r.regexpproto_stdMatcherGeneric(thisObj, s)
 	}
 	if rx.pattern.global {
+		rx.setOwnStr("lastIndex", intToValue(0), true)
 		res := rx.pattern.findAllSubmatchIndex(s, 0, -1, rx.pattern.sticky)
 		if len(res) == 0 {
-			rx.setOwnStr("lastIndex", intToValue(0), true)
 			return _null
 		}
 		a := make([]Value, 0, len(res))
 		for _, result := range res {
 			a = append(a, s.Substring(result[0], result[1]))
 		}
-		rx.setOwnStr("lastIndex", intToValue(int64(res[len(res)-1][1])), true)
 		return r.newArrayValues(a)
 	} else {
 		return rx.exec(s)
@@ -1226,17 +1226,16 @@ func (r *Runtime) regexpproto_stdReplacer(call FunctionCall) Value {
 	find := 1
 	if rx.pattern.global {
 		find = -1
-		rx.setOwnStr("lastIndex", intToValue(0), true)
 	} else {
 		index = rx.getLastIndex()
 	}
 	found := rx.pattern.findAllSubmatchIndex(s, toIntStrict(index), find, rx.pattern.sticky)
-	if len(found) > 0 {
-		if !rx.updateLastIndex(index, found[0], found[len(found)-1]) {
-			found = nil
+	if rx.pattern.global || rx.pattern.sticky {
+		var newLastIndex int64
+		if !rx.pattern.global && len(found) > 0 {
+			newLastIndex = int64(found[len(found)-1][1])
 		}
-	} else {
-		rx.updateLastIndex(index, nil, nil)
+		rx.setOwnStr("lastIndex", intToValue(newLastIndex), true)
 	}
 
 	return stringReplace(s, found, replaceStr, rcall)

regexp.go

@@ -2,13 +2,14 @@ package goja
 
 import (
 	"fmt"
-	"github.com/dlclark/regexp2"
-	"github.com/dop251/goja/unistring"
 	"io"
 	"regexp"
 	"sort"
 	"strings"
 	"unicode/utf16"
+
+	"github.com/dlclark/regexp2"
+	"github.com/dop251/goja/unistring"
 )
 
 type regexp2MatchCache struct {
@@ -538,33 +539,21 @@ func (r *regexpObject) getLastIndex() int64 {
 	return lastIndex
 }
 
-func (r *regexpObject) updateLastIndex(index int64, firstResult, lastResult []int) bool {
-	if r.pattern.sticky {
-		if firstResult == nil || int64(firstResult[0]) != index {
-			r.setOwnStr("lastIndex", intToValue(0), true)
-			return false
-		}
-	} else {
-		if firstResult == nil {
-			if r.pattern.global {
-				r.setOwnStr("lastIndex", intToValue(0), true)
-			}
-			return false
-		}
-	}
-
-	if r.pattern.global || r.pattern.sticky {
-		r.setOwnStr("lastIndex", intToValue(int64(lastResult[1])), true)
-	}
-	return true
-}
-
 func (r *regexpObject) execRegexp(target String) (match bool, result []int) {
 	index := r.getLastIndex()
 	if index >= 0 && index <= int64(target.Length()) {
 		result = r.pattern.findSubmatchIndex(target, int(index))
 	}
-	match = r.updateLastIndex(index, result, result)
+	match = len(result) > 0 && (!r.pattern.sticky || int64(result[0]) == index)
+
+	if r.pattern.global || r.pattern.sticky {
+		var newLastIndex int64
+		if match {
+			newLastIndex = int64(result[1])
+		}
+		r.setOwnStr("lastIndex", intToValue(newLastIndex), true)
+	}
+
 	return
 }
 

regexp_test.go

@@ -754,6 +754,31 @@ func TestRegexpUnicodeEscape(t *testing.T) {
 	testScriptWithTestLib(SCRIPT, _undefined, t)
 }
 
+func TestRegExpLastIndex(t *testing.T) {
+	const SCRIPT = `
+	function t(R, type) {
+		const re = new R("x+", "g");
+		re.exec("xxy");
+		assert.sameValue(re.lastIndex, 2, type+": exec");
+		"xxy".replace(re);
+		assert.sameValue(re.lastIndex, 0, type+": replace must reset lastIndex");
+		re.lastIndex = 1;
+		assert.sameValue("xxy".match(re)[0], "xx", type+": match");
+		assert.sameValue(re.lastIndex, 0, type+": match must reset lastIndex");
+	}
+
+	class CustomRegExp extends RegExp {
+		exec(s) {
+			return super.exec(s);
+		}
+	}
+
+	t(RegExp, "std");
+	t(CustomRegExp, "generic");
+	`
+	testScriptWithTestLib(SCRIPT, _undefined, t)
+}
+
 func BenchmarkRegexpSplitWithBackRef(b *testing.B) {
 	const SCRIPT = `
 	"aaaaaaaaaaaaaaaaaaaaaaaaa++bbbbbbbbbbbbbbbbbbbbbb+-ccccccccccccccccccccccc".split(/([+-])\1/)