fix: read the character actually beside a match for inline code

Signed-off-by: Joseph Kato <joseph@jdkato.io>

Author: jdkato

internal/core/location.go

@@ -118,6 +118,15 @@ func insideInlineMarkup(ctx string, fs []int) bool {
 		return true
 	}
 
+	// fs[1] is exclusive, so the character right beside the match is
+	// ctx[fs[1]] -- the check above looks one further out and misses a
+	// closing backtick sitting directly against the match, as in
+	// `f(x) # word`. Only backticks: a hyphen there is usually a compound
+	// word, and rejecting `well` in `well-known` would mislocate it.
+	if fs[1] < len(ctx) && ctx[fs[1]] == '`' {
+		return true
+	}
+
 	return false
 }
 
@@ -301,13 +310,8 @@ func initialPosition(ctx, txt string, a Alert, at int) (int, string) {
 		// by ignoring these inline code spans.
 		//
 		// TODO: What about `scope: raw`?
-		size := nlp.StrLen(ctx)
 		for _, fs := range fsi {
-			start := fs[0] - 1
-			end := fs[1] + 1
-			if start > 0 && (ctx[start] == '`' || ctx[start] == '-') {
-				continue
-			} else if end < size && (ctx[end] == '`' || ctx[end] == '-') {
+			if insideInlineMarkup(ctx, fs) {
 				continue
 			}
 			idx = fs[0]

internal/core/location_test.go

@@ -28,6 +28,50 @@ func TestInitialPositionPunctAnchor(t *testing.T) {
 	}
 }
 
+// A match butted directly against a code span's delimiter is inside (or
+// beside) that span, and locating an alert there mislocates it -- the prose
+// occurrence the rule actually matched sits later in the line. fs[1] is
+// exclusive, so the character to inspect is ctx[fs[1]] itself. See #1132's
+// follow-up: `Inline `+"`sum(x) # ZQX`"+` and text ZQX after.`
+func TestInsideInlineMarkup(t *testing.T) {
+	cases := []struct {
+		name string
+		ctx  string
+		fs   []int
+		want bool
+	}{
+		{"plain prose", "some ZQX here", []int{5, 8}, false},
+		{"opening backtick beside match", "x `ZQX` y", []int{3, 6}, true},
+		{"closing backtick against match", "x `f() # ZQX` and ZQX y",
+			[]int{9, 12}, true},
+		{"prose occurrence after a span", "x `f() # ZQX` and ZQX y",
+			[]int{18, 21}, false},
+		{"hyphenated compound is not markup", "a well-known fix",
+			[]int{2, 6}, false},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := insideInlineMarkup(c.ctx, c.fs); got != c.want {
+				t.Errorf("insideInlineMarkup(%q, %v) = %v, want %v",
+					c.ctx, c.fs, got, c.want)
+			}
+		})
+	}
+}
+
+// A match shadowed by an identical string inside a code span must be located
+// at its prose occurrence, not the span's.
+func TestInitialPositionSkipsCodeSpan(t *testing.T) {
+	ctx := "Inline `sum(x) # ZQX` and text ZQX after."
+	txt := "Inline ************ and text ZQX after."
+
+	pos, _ := initialPosition(ctx, txt, Alert{Match: "ZQX"}, -1)
+	if pos != 32 {
+		t.Errorf("pos = %d, want 32 (the prose occurrence)", pos)
+	}
+}
+
 func TestIsPunctOnly(t *testing.T) {
 	cases := map[string]bool{
 		",":      true,

testdata/e2e/misc.yaml

@@ -170,3 +170,33 @@ cases:
       test.md:17:25:Vale.Spelling:Did you really mean 'config'?
       test.md:23:78:Vale.Spelling:Did you really mean 'config'?
       test.md:23:85:Vale.Spelling:Did you really mean 'json'?
+
+  - name: shadowed-by-code-span
+    about: a match whose text also appears inside an earlier code span must be
+      reported at its prose occurrence, not the span's
+    files:
+      .vale.ini: |
+        StylesPath = styles
+        MinAlertLevel = suggestion
+
+        [*.md]
+        BasedOnStyles = T
+      styles/T/Tok.yml: |
+        extends: existence
+        message: "'%s' in text"
+        level: error
+        nonword: true
+        raw:
+          - ZQX
+      test.md: |
+        A first paragraph.
+
+        Inline `sum(x) # ZQX` and text ZQX after.
+
+        Both ZQX one and ZQX two.
+    args: test.md
+    exit: 1
+    want: |
+      test.md:3:32:T.Tok:'ZQX' in text
+      test.md:5:6:T.Tok:'ZQX' in text
+      test.md:5:18:T.Tok:'ZQX' in text