Use StatementRangeSyntaxError (#919)

* Add `'positron'` as "external"

To resolve

```
quarto:dev: ✘ [ERROR] Could not resolve "positron"
quarto:dev:
quarto:dev:     src/host/hooks.ts:19:23:
quarto:dev:       19 │ import * as hooks from 'positron';
```

* Rethrow new `StatementRangeSyntaxError` with unadjusted line number

* Guard `StatementRangeSyntaxError` usage with version requirement

* Remove `'positron'` from list of externals

I think this is causing test failures because in CI we run the tests as vscode, but in these externals we are trying to assert that positron will be available, and it's not

It would be nice to figure this out though, because this was required for me to run dev quarto with dev positron.

* Expose `StatementRangeSyntaxError` via `hooksAPI()`

This is why I was needing `'positron'` as an "external" before. We've never had to expose a class that we need to construct before, and it requires using it as a "value" rather than just as a "type" so it needs to show up in `PositronApi` and be called via `hooksApi()`

* Use lexicographic comparison for calendar versions

* CHANGELOG

Author: DavisVaughan

apps/vscode/CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## 1.131.0 (Unreleased)
 
+- Added support for Positron's statement execution feature that reports the approximate line number of the parse error (<https://github.com/quarto-dev/quarto/pull/919>).
 - Fixed a bug where `Quarto: Format Cell` would notify you that no formatter was available for code cells that were already formatted (<https://github.com/quarto-dev/quarto/pull/933>).
 
 ## 1.130.0 (Release on 2026-02-18)

apps/vscode/src/@types/hooks.d.ts

@@ -10,6 +10,7 @@ declare module 'positron' {
 		runtime: PositronRuntime;
 		languages: PositronLanguages;
 		window: PositronWindow;
+		StatementRangeSyntaxError: typeof StatementRangeSyntaxError;
 	}
 
 	export interface PositronRuntime {
@@ -58,6 +59,11 @@ declare module 'positron' {
 		readonly code?: string;
 	}
 
+	export class StatementRangeSyntaxError extends Error {
+		readonly line?: number;
+		constructor(line?: number);
+	}
+
 	export interface PositronWindow {
 		createPreviewPanel(
 			viewType: string,

apps/vscode/src/host/hooks.ts

@@ -18,11 +18,12 @@
 import * as vscode from 'vscode';
 import * as hooks from 'positron';
 
+import semver from "semver";
 import { ExtensionHost, HostWebviewPanel, HostStatementRangeProvider, HostHelpTopicProvider } from '.';
 import { CellExecutor, cellExecutorForLanguage, executableLanguages, isKnitrDocument, pythonWithReticulate } from './executors';
 import { ExecuteQueue } from './execute-queue';
 import { MarkdownEngine } from '../markdown/engine';
-import { virtualDoc, adjustedPosition, unadjustedRange, withVirtualDocUri, VirtualDocStyle } from "../vdoc/vdoc";
+import { virtualDoc, adjustedPosition, unadjustedRange, withVirtualDocUri, VirtualDocStyle, unadjustedLine } from "../vdoc/vdoc";
 import { Position, Range } from 'vscode';
 import { Uri } from 'vscode';
 
@@ -200,18 +201,45 @@ class EmbeddedStatementRangeProvider implements HostStatementRangeProvider {
     position: vscode.Position,
     token: vscode.CancellationToken): Promise<hooks.StatementRange | undefined> {
     const vdoc = await virtualDoc(document, position, this._engine, VirtualDocStyle.Block);
-    if (vdoc) {
-      return await withVirtualDocUri(vdoc, document.uri, "statementRange", async (uri: vscode.Uri) => {
+
+    if (!vdoc) {
+      return undefined;
+    }
+
+    return await withVirtualDocUri(vdoc, document.uri, "statementRange", async (uri: vscode.Uri) => {
+      try {
         const result = await vscode.commands.executeCommand<hooks.StatementRange>(
           "vscode.executeStatementRangeProvider",
           uri,
           adjustedPosition(vdoc.language, position)
         );
         return { range: unadjustedRange(vdoc.language, result.range), code: result.code };
-      });
-    } else {
-      return undefined;
-    }
+      } catch (err) {
+        let hooks = hooksApi();
+
+        if (!hooks) {
+          throw err;
+        }
+
+        // TODO: Remove this once `apps/vscode/package.json` bumps to `"positron": "^2026.03.0"` or higher.
+        // For now we avoid aggressive bumping due to https://github.com/posit-dev/positron/issues/11321.
+        // We can't use `semver.lt()` because calendar versioning isn't compatible with semver due to the
+        // leading `0` in `03`. Instead, we use lexicographic string comparison and rely on the year and
+        // month to be zero padded so sorting always works correctly.
+        if (hooks.version < "2026.03.0") {
+          throw err;
+        }
+
+        if (err instanceof hooks.StatementRangeSyntaxError) {
+          // Rethrow syntax error with unadjusted line number, so Positron's notification will
+          // jump to the correct line
+          throw new hooks.StatementRangeSyntaxError(err.line ? unadjustedLine(vdoc.language, err.line) : undefined);
+        } else {
+          // Rethrow unrecognized error
+          throw err;
+        }
+      }
+    });
   };
 }
 

apps/vscode/src/vdoc/vdoc.ts

@@ -240,13 +240,21 @@ export function isBlockOfLanguage(language: EmbeddedLanguage) {
   };
 }
 
-// adjust position for inject
+// adjust line for inject
+export function adjustedLine(language: EmbeddedLanguage, line: number): number {
+  return line + (language.inject?.length || 0);
+}
+
+export function unadjustedLine(language: EmbeddedLanguage, line: number): number {
+  return line - (language.inject?.length || 0);
+}
+
 export function adjustedPosition(language: EmbeddedLanguage, pos: Position) {
-  return new Position(pos.line + (language.inject?.length || 0), pos.character);
+  return new Position(adjustedLine(language, pos.line), pos.character);
 }
 
 export function unadjustedPosition(language: EmbeddedLanguage, pos: Position) {
-  return new Position(pos.line - (language.inject?.length || 0), pos.character);
+  return new Position(unadjustedLine(language, pos.line), pos.character);
 }
 
 export function unadjustedRange(language: EmbeddedLanguage, range: Range) {