fix(vscode): resolve correctness & robustness bugs from extension bug hunt

Adversarially-verified bug hunt across the VS Code extension. Fixes:

- resxDiagnostics: use path.basename so language-code extraction works on
  Windows (lastIndexOf('/') returned -1, breaking all diagnostics there).
- jsonDocumentParser: duplicate simple key names in different scopes now
  resolve to their own location (scoped offset search); multi-line values
  carry a real endLine; getKeyRange returns null for missing keys instead
  of a bogus 0,0 range.
- extension: ensureBackendReady() guard so commands don't crash with
  'Cannot read properties of undefined' when backend init failed; the
  Restart Backend recovery path stays usable. File-watcher refresh is
  debounced + serialized to avoid concurrent invalidate/refetch races.
- dashboard: coerce stats numbers so a malformed response never renders NaN.
- resourceTreeView: null-safe key.values to avoid crashing the tree render.
- definitionProvider: fallback paths return a Range (highlights) not a
  bare Position.
- completionProvider: invalidateCache() also drops the config cache so
  lrm.json changes take effect immediately.
- statusBar: tooltip shows 0 instead of undefined total keys.
- resourceEditor: guard missing default language in Auto-Translate.
- codeLens/cacheService: data-annotation keys now resolve details and
  coverage against the group named by their ResourceType (already on the
  wire as resourceTypeClassName); getMissingLanguages is group-aware.

Adds regression tests for the JSON parser and CodeLens fixes.

Author: nickprotop

vscode-extension/src/backend/apiClient.ts

@@ -40,6 +40,14 @@ export interface KeyReference {
     pattern: string;
     confidence: string;
     warning?: string;
+    /**
+     * For keys referenced via a Data Annotation (e.g.
+     * `[Display(..., ResourceType = typeof(GlassResources))]`), the simple class name
+     * of the bound resource type ("GlassResources"). Maps to a resx group's base name,
+     * so a typed reference can be resolved against the correct group in multi-group
+     * projects. Undefined for ordinary, group-agnostic references.
+     */
+    resourceTypeClassName?: string;
 }
 
 export interface KeyUsage {

vscode-extension/src/backend/cacheService.ts

@@ -341,8 +341,8 @@ function setupEventListeners(context: vscode.ExtensionContext, enableRealtimeSca
     const iosWatcher = vscode.workspace.createFileSystemWatcher('**/*.lproj/*.strings');
     const lrmConfigWatcher = vscode.workspace.createFileSystemWatcher('**/lrm.json');
 
-    // Helper to handle resource file changes
-    const handleResourceChange = async () => {
+    // The actual refresh. Kept private; callers go through the debounced wrapper below.
+    const runResourceRefresh = async () => {
         // Invalidate shared cache first
         if (cacheService) {
             cacheService.invalidate();
@@ -357,6 +357,48 @@ function setupEventListeners(context: vscode.ExtensionContext, enableRealtimeSca
         }
     };
 
+    // Debounce + serialize resource-change handling. Without this, saving several
+    // resource files at once fires many concurrent handlers that each invalidate the
+    // cache and refetch, interleaving into an inconsistent tree/diagnostics view and
+    // doing redundant work. We coalesce a burst into a single trailing refresh, and
+    // never run two refreshes concurrently (a change arriving mid-refresh schedules
+    // one more run afterwards).
+    let refreshTimer: NodeJS.Timeout | undefined;
+    let refreshInFlight: Promise<void> | undefined;
+    let rerunRequested = false;
+    const RESOURCE_REFRESH_DEBOUNCE_MS = 250;
+
+    const handleResourceChange = async (): Promise<void> => {
+        if (refreshTimer) {
+            clearTimeout(refreshTimer);
+        }
+        await new Promise<void>(resolve => {
+            refreshTimer = setTimeout(() => {
+                refreshTimer = undefined;
+                resolve();
+            }, RESOURCE_REFRESH_DEBOUNCE_MS);
+        });
+
+        // If a refresh is already running, ask it to run once more when it finishes
+        // rather than starting an overlapping one.
+        if (refreshInFlight) {
+            rerunRequested = true;
+            return refreshInFlight;
+        }
+
+        const drain = async (): Promise<void> => {
+            do {
+                rerunRequested = false;
+                await runResourceRefresh();
+            } while (rerunRequested);
+        };
+
+        refreshInFlight = drain().finally(() => {
+            refreshInFlight = undefined;
+        });
+        return refreshInFlight;
+    };
+
     // Helper to filter JSON events to only resource files (exclude config files)
     const isResourceJson = (uri: vscode.Uri): boolean => {
         const fileName = uri.fsPath.toLowerCase();
@@ -439,10 +481,29 @@ function setupEventListeners(context: vscode.ExtensionContext, enableRealtimeSca
     });
 }
 
+/**
+ * True once the backend and its dependent globals (apiClient, cacheService, …) were
+ * initialized successfully during activation. When the backend fails to start, those
+ * globals stay undefined but registerCommands() still runs, so command handlers must
+ * check this before dereferencing them — otherwise any command throws a confusing
+ * "Cannot read properties of undefined". lrmService itself is created before the
+ * try block, so the Restart Backend command remains usable to recover.
+ */
+function ensureBackendReady(): boolean {
+    if (!apiClient || !cacheService) {
+        vscode.window.showErrorMessage(
+            'LRM backend is not running. Use "LRM: Restart Backend" to try again, or check the LRM output log.'
+        );
+        return false;
+    }
+    return true;
+}
+
 function registerCommands(context: vscode.ExtensionContext) {
     // Scan Code
     context.subscriptions.push(
         vscode.commands.registerCommand('lrm.scanCode', async () => {
+            if (!ensureBackendReady()) return;
             try {
                 const result = await vscode.window.withProgress({
                     location: vscode.ProgressLocation.Notification,
@@ -501,6 +562,7 @@ function registerCommands(context: vscode.ExtensionContext) {
     // Validate Resources
     context.subscriptions.push(
         vscode.commands.registerCommand('lrm.validateResources', async () => {
+            if (!ensureBackendReady()) return;
             try {
                 const result = await vscode.window.withProgress({
                     location: vscode.ProgressLocation.Notification,
@@ -530,6 +592,7 @@ function registerCommands(context: vscode.ExtensionContext) {
     // Open Resource Editor
     context.subscriptions.push(
         vscode.commands.registerCommand('lrm.openResourceEditor', async () => {
+            if (!ensureBackendReady()) return;
             ResourceEditorPanel.createOrShow(context.extensionUri, apiClient, cacheService);
         })
     );
@@ -981,13 +1044,15 @@ function registerCommands(context: vscode.ExtensionContext) {
     // Open Dashboard
     context.subscriptions.push(
         vscode.commands.registerCommand('lrm.openDashboard', () => {
+            if (!ensureBackendReady()) return;
             DashboardPanel.createOrShow(apiClient);
         })
     );
 
     // Open Settings
     context.subscriptions.push(
         vscode.commands.registerCommand('lrm.openSettings', () => {
+            if (!ensureBackendReady()) return;
             SettingsPanel.createOrShow(apiClient);
         })
     );

vscode-extension/src/extension.ts

@@ -42,8 +42,11 @@ export class JsonDocumentParser implements IResourceDocumentParser {
 
         // Find the key whose range contains the position
         for (const key of keys) {
+            if (key.lineNumber < 0) {
+                continue;
+            }
             const keyOffset = document.offsetAt(new vscode.Position(key.lineNumber, key.columnStart));
-            const endOffset = document.offsetAt(new vscode.Position(key.lineNumber, key.columnEnd));
+            const endOffset = document.offsetAt(new vscode.Position(key.endLine ?? key.lineNumber, key.columnEnd));
 
             // Expand range to include the full key-value pair
             // Look backwards for the key start
@@ -64,8 +67,13 @@ export class JsonDocumentParser implements IResourceDocumentParser {
 
         for (const key of keys) {
             if (key.key === keyName) {
+                // lineNumber -1 means the key was parsed but its text location could
+                // not be resolved; return null rather than a bogus range at 0,0.
+                if (key.lineNumber < 0) {
+                    return null;
+                }
                 const startPos = new vscode.Position(key.lineNumber, key.columnStart);
-                const endPos = new vscode.Position(key.lineNumber, key.columnEnd);
+                const endPos = new vscode.Position(key.endLine ?? key.lineNumber, key.columnEnd);
                 return new vscode.Range(startPos, endPos);
             }
         }
@@ -81,12 +89,18 @@ export class JsonDocumentParser implements IResourceDocumentParser {
         prefix: string,
         keys: ResourceKey[],
         text: string,
-        document: vscode.TextDocument
+        document: vscode.TextDocument,
+        searchFrom = 0
     ): void {
         if (typeof obj !== 'object' || obj === null) {
             return;
         }
 
+        // Local cursor advanced past each key as it is consumed, so sibling keys —
+        // and identical simple names nested under different parents — resolve to
+        // distinct, in-order locations rather than all matching the first occurrence.
+        let cursor = searchFrom;
+
         for (const [key, value] of Object.entries(obj)) {
             // Skip metadata properties (except when they contain the value)
             if (key.startsWith('_') && key !== '_value') {
@@ -97,7 +111,8 @@ export class JsonDocumentParser implements IResourceDocumentParser {
 
             if (typeof value === 'string') {
                 // Simple string value
-                const location = this.findKeyLocation(text, document, prefix ? key : fullKey);
+                const { endOffset, ...location } = this.findKeyLocation(text, document, key, cursor);
+                if (location.lineNumber !== -1) cursor = endOffset;
                 keys.push({
                     key: fullKey,
                     value,
@@ -107,7 +122,8 @@ export class JsonDocumentParser implements IResourceDocumentParser {
                 if (this.isPluralObject(value)) {
                     // Plural object
                     const pluralForms = this.extractPluralForms(value);
-                    const location = this.findKeyLocation(text, document, key);
+                    const { endOffset, ...location } = this.findKeyLocation(text, document, key, cursor);
+                    if (location.lineNumber !== -1) cursor = endOffset;
                     keys.push({
                         key: fullKey,
                         value: pluralForms['other'] || pluralForms['one'] || Object.values(pluralForms)[0] || '',
@@ -120,16 +136,24 @@ export class JsonDocumentParser implements IResourceDocumentParser {
                     const valueObj = value as Record<string, unknown>;
                     const val = valueObj._value as string;
                     const comment = valueObj._comment as string | undefined;
-                    const location = this.findKeyLocation(text, document, key);
+                    const { endOffset, ...location } = this.findKeyLocation(text, document, key, cursor);
+                    if (location.lineNumber !== -1) cursor = endOffset;
                     keys.push({
                         key: fullKey,
                         value: val,
                         comment,
                         ...location
                     });
                 } else {
-                    // Recurse into nested object
-                    this.extractKeys(value, fullKey, keys, text, document);
+                    // Recurse into nested object. Locate the parent key first so the
+                    // child scope is searched from inside the parent's braces — this
+                    // is what disambiguates duplicate simple names across scopes.
+                    const parent = this.findKeyLocation(text, document, key, cursor);
+                    if (parent.lineNumber !== -1) cursor = parent.endOffset;
+                    const childStart = parent.lineNumber !== -1
+                        ? document.offsetAt(new vscode.Position(parent.lineNumber, parent.columnStart))
+                        : cursor;
+                    this.extractKeys(value, fullKey, keys, text, document, childStart);
                 }
             }
         }
@@ -186,7 +210,8 @@ export class JsonDocumentParser implements IResourceDocumentParser {
                             keys[existingIndex].pluralForms = pluralForms;
                         } else {
                             // Add as new plural key
-                            const location = this.findKeyLocation(text, document, `${baseKey}_one`);
+                            const { endOffset, ...location } = this.findKeyLocation(text, document, `${baseKey}_one`);
+                            void endOffset;
                             keys.push({
                                 key: fullKey,
                                 value: pluralForms['other'] || pluralForms['one'] || Object.values(pluralForms)[0],
@@ -255,12 +280,17 @@ export class JsonDocumentParser implements IResourceDocumentParser {
     private findKeyLocation(
         text: string,
         document: vscode.TextDocument,
-        key: string
-    ): { lineNumber: number; columnStart: number; columnEnd: number; comment?: string } {
-        // Search for the key in the text
+        key: string,
+        searchFrom = 0
+    ): { lineNumber: number; columnStart: number; endLine: number; columnEnd: number; comment?: string; endOffset: number } {
+        // Search for the key in the text starting at searchFrom. The caller advances
+        // searchFrom past each key it has already consumed so that the same simple
+        // name appearing in different nesting scopes (e.g. users.id vs posts.id)
+        // resolves to its OWN occurrence rather than always the first global match.
         // Pattern: "key": "value" or "key": { ... }
         const escapedKey = this.escapeRegexChars(key);
-        const keyPattern = new RegExp(`"${escapedKey}"\\s*:`);
+        const keyPattern = new RegExp(`"${escapedKey}"\\s*:`, 'g');
+        keyPattern.lastIndex = Math.max(0, searchFrom);
         const match = keyPattern.exec(text);
 
         if (match) {
@@ -307,15 +337,23 @@ export class JsonDocumentParser implements IResourceDocumentParser {
             return {
                 lineNumber: startPos.line,
                 columnStart: startPos.character,
-                columnEnd: endPos.character
+                // Carry the real end line so multi-line values (multiline strings,
+                // object values) produce a correct range instead of collapsing the
+                // end onto the start line.
+                endLine: endPos.line,
+                columnEnd: endPos.character,
+                endOffset
             };
         }
 
-        // Key not found - return defaults
+        // Key not found. Use lineNumber -1 as a sentinel so callers (getKeyRange)
+        // can return null instead of pointing at a bogus 0,0 location.
         return {
-            lineNumber: 0,
+            lineNumber: -1,
             columnStart: 0,
-            columnEnd: 0
+            endLine: -1,
+            columnEnd: 0,
+            endOffset: Math.max(0, searchFrom)
         };
     }
 

vscode-extension/src/parsers/jsonDocumentParser.ts

@@ -10,10 +10,12 @@ export interface ResourceKey {
     value: string;
     /** Optional comment/description */
     comment?: string;
-    /** Line number in the document (0-based) */
+    /** Line number in the document (0-based). -1 means the key could not be located. */
     lineNumber: number;
     /** Column start position */
     columnStart: number;
+    /** End line number (0-based). Defaults to lineNumber when the value is single-line. */
+    endLine?: number;
     /** Column end position */
     columnEnd: number;
     /** Whether this is a plural key */

vscode-extension/src/parsers/resourceDocumentParser.ts

@@ -255,6 +255,16 @@ export class LrmCodeLensProvider implements vscode.CodeLensProvider {
 
             const keyName = usage.key;
 
+            // If any reference binds this key to a specific resource group via a Data
+            // Annotation's ResourceType (e.g. typeof(GlassResources)), resolve details
+            // against THAT group. Otherwise the key is group-agnostic and we fall back
+            // to whichever group the backend resolved it against (its union default).
+            // Without this, getKeyDetails(keyName) returns the first-cached group's
+            // details, showing the wrong value/coverage in multi-group projects.
+            const boundGroup = (usage.references || [])
+                .map(r => r.resourceTypeClassName)
+                .find(g => g && g.trim() !== '') || undefined;
+
             for (const reference of usage.references || []) {
                 // Backend reports 1-based line numbers; CodeLens positions are 0-based.
                 const lineNumber = Math.max(0, (reference.line ?? 1) - 1);
@@ -281,7 +291,7 @@ export class LrmCodeLensProvider implements vscode.CodeLensProvider {
                 }
 
                 try {
-                    const details = await this.cacheService.getKeyDetails(keyName);
+                    const details = await this.cacheService.getKeyDetails(keyName, false, boundGroup);
 
                     // Show value lens
                     if (config.get<boolean>('codeLens.showValue', true)) {
@@ -305,7 +315,7 @@ export class LrmCodeLensProvider implements vscode.CodeLensProvider {
                     }
 
                     // Show missing languages lens
-                    const missingLanguages = this.cacheService.getMissingLanguages(keyName);
+                    const missingLanguages = this.cacheService.getMissingLanguages(keyName, boundGroup);
                     if (missingLanguages && missingLanguages.length > 0) {
                         // Filter out 'default' from missing list
                         const displayMissing = missingLanguages.filter(l => l !== 'default' && l !== '');

vscode-extension/src/providers/codeLens.ts

@@ -239,5 +239,9 @@ export class LocalizationCompletionProvider implements vscode.CompletionItemProv
      */
     public invalidateCache(): void {
         this.keysCache = null;
+        // Also drop the cached configuration: changes to lrm.json (resource class
+        // names, localizationMethods) must take effect on the next completion rather
+        // than waiting out the config TTL.
+        this.configCache = null;
     }
 }

vscode-extension/src/providers/completionProvider.ts

@@ -228,8 +228,11 @@ export class LrmDefinitionProvider implements vscode.DefinitionProvider {
                 const match = pattern.exec(text);
 
                 if (match) {
-                    const pos = document.positionAt(match.index);
-                    return new vscode.Location(fileUri, pos);
+                    // Return a Range (not a bare Position) so Go-to-Definition
+                    // highlights the match, matching the parser path's behavior.
+                    const start = document.positionAt(match.index);
+                    const end = document.positionAt(match.index + match[0].length);
+                    return new vscode.Location(fileUri, new vscode.Range(start, end));
                 }
             } else if (fileName.endsWith('.json')) {
                 // JSON pattern: "KeyName":
@@ -240,8 +243,9 @@ export class LrmDefinitionProvider implements vscode.DefinitionProvider {
                 const match = pattern.exec(text);
 
                 if (match) {
-                    const pos = document.positionAt(match.index);
-                    return new vscode.Location(fileUri, pos);
+                    const start = document.positionAt(match.index);
+                    const end = document.positionAt(match.index + match[0].length);
+                    return new vscode.Location(fileUri, new vscode.Range(start, end));
                 }
             }
         } catch (error) {

vscode-extension/src/providers/definitionProvider.ts

@@ -126,7 +126,10 @@ export class ResxDiagnosticProvider {
 
         try {
             const document = await vscode.workspace.openTextDocument(fileUri);
-            const fileName = fileUri.fsPath.substring(fileUri.fsPath.lastIndexOf('/') + 1);
+            // Use path.basename so this works on Windows too: fsPath uses backslashes
+            // there, and lastIndexOf('/') would return -1 and yield the whole path,
+            // breaking language-code extraction (no diagnostics on Windows).
+            const fileName = path.basename(fileUri.fsPath);
 
             // Determine language code from filename
             // e.g., Resources.el.resx -> el, Resources.resx -> default