M function matcher vue template (#4317)

Closes opral/sherlock#197

Add a failing unit test to reproduce the issue where the m-function
matcher doesn't match calls in Vue templates.

---
<a
href="https://cursor.com/background-agent?bcId=bc-7702ee9c-de8a-42af-9acf-d57050db30d7"><picture><source
media="(prefers-color-scheme: dark)"
srcset="https://cursor.com/open-in-cursor-dark.svg"><source
media="(prefers-color-scheme: light)"
srcset="https://cursor.com/open-in-cursor-light.svg"><img alt="Open in
Cursor"
src="https://cursor.com/open-in-cursor.svg"></picture></a>&nbsp;<a
href="https://cursor.com/agents?id=bc-7702ee9c-de8a-42af-9acf-d57050db30d7"><picture><source
media="(prefers-color-scheme: dark)"
srcset="https://cursor.com/open-in-web-dark.svg"><source
media="(prefers-color-scheme: light)"
srcset="https://cursor.com/open-in-web-light.svg"><img alt="Open in Web"
src="https://cursor.com/open-in-web.svg"></picture></a>


<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Enhances message matching to better detect usages and reduce false
positives.
> 
> - Match `m()` references inside Vue `<template>` blocks and when used
before the import appears
> - Require a real `m` import (`import * as m` or named `{ m }`) before
returning any matches
> - Strip comments/strings during the import scan to avoid false
positives (e.g. commented or stringified imports)
> - Adjust parser to validate the character before `m`, and refactor
`createParser` to accept `sourceCode`
> - Update/add tests covering Vue templates, pre-import usage, and
ignoring commented/string imports
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
1c0fcdf. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>

Author: samuelstroschein

.changeset/m-function-matcher-vue-template.md

@@ -0,0 +1,6 @@
+---
+"@inlang/plugin-m-function-matcher": minor
+---
+
+Match m() references in Vue templates and before imports. Fixes
+https://github.com/opral/sherlock/issues/197.

packages/plugins/m-function-matcher/src/ideExtension/messageReferenceMatchers.test.ts

@@ -432,6 +432,23 @@ describe("Paraglide Message Parser", () => {
    ]);
   });
 
+  it("repro: should match m calls in Vue template before import", () => {
+    const sourceCode = `
+<template>
+  <span>{{ m["common.addNew"]() }}</span>
+</template>
+<script setup lang="ts">
+import * as m from "@/paraglide/messages";
+const testRef = m["common.addNew"]();
+</script>
+`;
+    const result = parse(sourceCode) as Array<{ messageId: string }>;
+    expect(result.map((item) => item.messageId)).toEqual([
+      "common.addNew",
+      "common.addNew",
+    ]);
+  });
+
   it("should match if both dot and bracket notation are used in the same file", () => {
     const sourceCode = `
 		import * as m from "../../i18n-generated/messages";
@@ -471,7 +488,15 @@ describe("Paraglide Message Parser", () => {
 		import * as m from "../../i18n-generated/messages";
 		`;
     const result = parse(sourceCode);
-    expect(result).toEqual([]);
+    expect(result).toEqual([
+      {
+        messageId: "helloWorld",
+        position: {
+          start: { line: 2, character: 5 },
+          end: { line: 2, character: 17 },
+        },
+      },
+    ]);
   });
 
   it("should match if m is defined but no reference to paraglide", () => {
@@ -482,6 +507,17 @@ describe("Paraglide Message Parser", () => {
     expect(result).toEqual([]);
   });
 
+  it("should ignore m imports in comments or strings", () => {
+    const sourceCode = `
+		const m = Math;
+		m.max(1, 2);
+		// import { m } from "@/paraglide/messages"
+		const note = "import { m } from '@/paraglide/messages'";
+		`;
+    const result = parse(sourceCode);
+    expect(result).toEqual([]);
+  });
+
   it("should match if m is defined but has a spell error", () => {
     const sourceCode = `
 		import * as m from "../../i18n-generated/messages";

packages/plugins/m-function-matcher/src/ideExtension/messageReferenceMatchers.ts

@@ -9,10 +9,137 @@
 
 import Parsimmon from "parsimmon";
 
-const createParser = () => {
+const mImportPattern = /import\s+(?:\*\s+as\s+m|\{\s*[^}]*\bm\b[^}]*\})/;
+
+const stripCommentsAndStrings = (sourceCode: string) => {
+  let result = "";
+  let i = 0;
+  const length = sourceCode.length;
+  let state: "code" | "singleLineComment" | "multiLineComment" | "singleQuote" | "doubleQuote" | "template" =
+    "code";
+
+  while (i < length) {
+    const char = sourceCode[i];
+    const next = sourceCode[i + 1];
+
+    if (state === "code") {
+      if (char === "/" && next === "/") {
+        state = "singleLineComment";
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      if (char === "/" && next === "*") {
+        state = "multiLineComment";
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      if (char === "'") {
+        state = "singleQuote";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      if (char === '"') {
+        state = "doubleQuote";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      if (char === "`") {
+        state = "template";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      result += char;
+      i += 1;
+      continue;
+    }
+
+    if (state === "singleLineComment") {
+      if (char === "\n") {
+        state = "code";
+        result += "\n";
+      } else {
+        result += " ";
+      }
+      i += 1;
+      continue;
+    }
+
+    if (state === "multiLineComment") {
+      if (char === "*" && next === "/") {
+        state = "code";
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      result += char === "\n" ? "\n" : " ";
+      i += 1;
+      continue;
+    }
+
+    if (state === "singleQuote") {
+      if (char === "\\" && i + 1 < length) {
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      if (char === "'") {
+        state = "code";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      result += char === "\n" ? "\n" : " ";
+      i += 1;
+      continue;
+    }
+
+    if (state === "doubleQuote") {
+      if (char === "\\" && i + 1 < length) {
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      if (char === '"') {
+        state = "code";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      result += char === "\n" ? "\n" : " ";
+      i += 1;
+      continue;
+    }
+
+    if (state === "template") {
+      if (char === "\\" && i + 1 < length) {
+        result += "  ";
+        i += 2;
+        continue;
+      }
+      if (char === "`") {
+        state = "code";
+        result += " ";
+        i += 1;
+        continue;
+      }
+      result += char === "\n" ? "\n" : " ";
+      i += 1;
+      continue;
+    }
+  }
+
+  return result;
+};
+
+const createParser = (sourceCode: string) => {
   return Parsimmon.createLanguage({
     entry: (r) => {
-      return Parsimmon.alt(r.findReference!, Parsimmon.any)
+      return Parsimmon.alt(r.findMessage!, Parsimmon.any)
         .many()
         .map((matches) => matches.flatMap((match) => match))
         .map((matches) =>
@@ -94,12 +221,22 @@ const createParser = () => {
 
     findMessage: (r) => {
       return Parsimmon.seqMap(
-        Parsimmon.regex(/.*?(?<![a-zA-Z0-9/])m/s), // find m that's not preceded by letters/numbers
+        Parsimmon.index, // capture start offset
+        Parsimmon.regex(/.*?m/s), // find earliest m from current position
         Parsimmon.alt(r.dotNotation!, r.bracketNotation!).or(
           Parsimmon.succeed(null)
         ),
         Parsimmon.regex(/\((?:[^()]|\([^()]*\))*\)/).or(Parsimmon.succeed("")), // function arguments or empty string
-        (_, notation, args) => {
+        (startIndex, match, notation, args) => {
+          const mOffset = startIndex.offset + match.length - 1;
+          const prevChar =
+            mOffset > 0 ? sourceCode[mOffset - 1] ?? "" : "";
+          const hasValidPrefix =
+            mOffset === 0 || !/[a-zA-Z0-9/]/.test(prevChar);
+
+          if (!hasValidPrefix) {
+            return null;
+          }
           // false positive (m not followed by dot or bracket notation)
           if (notation === null) {
             return null;
@@ -126,7 +263,11 @@ const createParser = () => {
 // Parse the expression
 export function parse(sourceCode: string) {
   try {
-    const parser = createParser();
+    const scanSource = sourceCode ? stripCommentsAndStrings(sourceCode) : "";
+    if (!scanSource || !mImportPattern.test(scanSource)) {
+      return [];
+    }
+    const parser = createParser(sourceCode);
     return parser.entry!.tryParse(sourceCode);
   } catch (e) {
     return [];