fix parser error highlight offsets for non-suffix slices

Co-authored-by: Thomas Pelletier <thomas@pelletier.dev>

errors_test.go

@@ -202,38 +202,6 @@ func TestDecodeError_Accessors(t *testing.T) {
 	assert.Equal(t, "bar", e.String())
 }
 
-func TestDecodeError_InvalidKeyStartAfterComment(t *testing.T) {
-	// Regression for https://github.com/pelletier/go-toml/issues/1047: the "="
-	// that starts an invalid keyval must be reported on line 2, column 1, with
-	// the human-readable context pointing at that byte (not the document end).
-	doc := "# comment\n= \"value\""
-
-	var v map[string]any
-	err := Unmarshal([]byte(doc), &v)
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-
-	var derr *DecodeError
-	if !errors.As(err, &derr) {
-		t.Fatalf("expected *DecodeError, got %T", err)
-	}
-
-	row, col := derr.Position()
-	if row != 2 || col != 1 {
-		t.Errorf("Position(): got row %d col %d, want row 2 col 1", row, col)
-	}
-
-	human := derr.String()
-	if !strings.Contains(human, `2| = "value"`) {
-		t.Errorf("human output should show the error line; got:\n%s", human)
-	}
-	// Caret line uses line-number column width padding; only the "| ~" part is stable here.
-	if !strings.Contains(human, "| ~ invalid character at start of key") {
-		t.Errorf("human output should underline '=' and include the parser message; got:\n%s", human)
-	}
-}
-
 func TestDecodeError_DuplicateContent(t *testing.T) {
 	// This test verifies that when the same content appears multiple times
 	// in the document, the error correctly points to the actual location
@@ -318,6 +286,27 @@ func TestDecodeError_Position(t *testing.T) {
 	}
 }
 
+func TestDecodeError_InvalidKeyStartAfterComment(t *testing.T) {
+	doc := "# comment\n= \"value\""
+
+	var out map[string]string
+	err := Unmarshal([]byte(doc), &out)
+	assert.Error(t, err)
+
+	var derr *DecodeError
+	if !errors.As(err, &derr) {
+		t.Fatal("error not in expected format")
+	}
+
+	row, col := derr.Position()
+	assert.Equal(t, 2, row)
+	assert.Equal(t, 1, col)
+	assert.Equal(t, "toml: invalid character at start of key: =", derr.Error())
+	assert.Equal(t, `1| # comment
+2| = "value"
+ | ~ invalid character at start of key: =`, derr.String())
+}
+
 func TestStrictErrorUnwrap(t *testing.T) {
 	fo := bytes.NewBufferString(`
 Missing = 1

unstable/parser.go

@@ -70,8 +70,8 @@ func (p *Parser) Data() []byte {
 // panics.
 func (p *Parser) Range(b []byte) Range {
 	return Range{
-		Offset: uint32(subsliceOffset(p.data, b)), //nolint:gosec // TOML documents are small
+		Offset: uint32(p.subsliceOffset(b)), //nolint:gosec // TOML documents are small
-		Length: uint32(len(b)),                    //nolint:gosec // TOML documents are small
+		Length: uint32(len(b)),              //nolint:gosec // TOML documents are small
 	}
 }
 
@@ -83,20 +83,22 @@ func (p *Parser) rangeOfToken(token, rest []byte) Range {
 	return Range{Offset: uint32(offset), Length: uint32(len(token))} //nolint:gosec // TOML documents are small
 }
 
-// subsliceOffset returns the byte offset of subslice b within data.
+// subsliceOffset returns the byte offset of subslice b within p.data.
-// b must share the same backing array as data (any subslice of data).
+// b must share the same backing array as p.data.
-func subsliceOffset(data, b []byte) int {
+func (p *Parser) subsliceOffset(b []byte) int {
 	if len(b) == 0 {
-		return 0
+		// Most callers pass suffix slices, so preserve EOF behavior.
+		return len(p.data)
 	}
 
-	dataPtr := reflect.ValueOf(data).Pointer()
+	dataPtr := reflect.ValueOf(p.data).Pointer()
-	bPtr := reflect.ValueOf(b).Pointer()
+	subPtr := reflect.ValueOf(b).Pointer()
 
-	offset := int(bPtr - dataPtr)
+	offset := int(subPtr - dataPtr)
-	if offset < 0 || offset > len(data) {
+	if offset < 0 || offset+len(b) > len(p.data) {
-		panic("subslice is not within data")
+		panic("subslice is not within parser input")
 	}
+
 	return offset
 }
 

unstable/parser_range_test.go

@@ -1,36 +0,0 @@
-package unstable
-
-import (
-	"errors"
-	"testing"
-)
-
-// Regression test for https://github.com/pelletier/go-toml/issues/1047:
-// Parser.Range must use the real slice offset, not len(data)-len(slice).
-func TestParser_Range_HighlightAfterComment(t *testing.T) {
-	input := []byte("# comment\n= \"value\"")
-
-	var p Parser
-	p.Reset(input)
-	for p.NextExpression() {
-	}
-	err := p.Error()
-	if err == nil {
-		t.Fatal("expected an error")
-	}
-
-	var perr *ParserError
-	if !errors.As(err, &perr) {
-		t.Fatalf("expected *ParserError, got %T", err)
-	}
-
-	r := p.Range(perr.Highlight)
-	shape := p.Shape(r)
-
-	if r.Offset != 10 {
-		t.Errorf("Range offset: got %d, want 10", r.Offset)
-	}
-	if shape.Start.Line != 2 || shape.Start.Column != 1 {
-		t.Errorf("position: got %d:%d, want 2:1", shape.Start.Line, shape.Start.Column)
-	}
-}