Merge remote-tracking branch 'origin/main' into dependabot/npm_and_yarn/typescript-7.0.2

# Conflicts:
#	CONTRIBUTING.md
#	test/suite/index.ts

Co-authored-by: chagong <831821+chagong@users.noreply.github.com>

Author: Copilot

CONTRIBUTING.md

@@ -27,7 +27,7 @@ javaDebugger/
 ### Prerequisites
 - [JDK](http://www.oracle.com/technetwork/java/javase/downloads/index.html), (version 11 or later)
 - [VS Code](https://code.visualstudio.com/), (version 1.44.0 or later)
-- [Node.JS](https://nodejs.org/en/), (>= 20)
+- [Node.JS](https://nodejs.org/en/), (20.x or 22+)
 - [Language Support for Java by Red Hat](https://marketplace.visualstudio.com/items?itemName=redhat.java), (version 0.60.0 or later)
 
 Install all the dependencies using `npm` (supposed to be installed together with [Node.JS](https://nodejs.org/en/)).

package-lock.json

@@ -21,7 +21,8 @@
     "debugger"
   ],
   "engines": {
-    "vscode": "^1.95.0"
+    "vscode": "^1.95.0",
+    "node": "20 || >=22"
   },
   "license": "SEE LICENSE IN LICENSE.txt",
   "repository": {
@@ -1403,7 +1404,6 @@
     "dotenv": "^17.4.2",
     "lodash": "^4.18.0",
     "vscode-extension-telemetry-wrapper": "^0.15.3",
-    "vscode-languageclient": "6.0.0-next.9",
     "vscode-languageserver-types": "3.18.0",
     "vscode-tas-client": "^0.1.84"
   },

package.json

@@ -4,12 +4,19 @@
 import { debug, InlineValue, InlineValueContext, InlineValueEvaluatableExpression, InlineValuesProvider, InlineValueText, InlineValueVariableLookup,
     Range, TextDocument } from "vscode";
 import { instrumentOperation, instrumentOperationStep, sendInfo } from "vscode-extension-telemetry-wrapper";
-import * as CodeConverter from "vscode-languageclient/lib/codeConverter";
-import * as ProtocolConverter from "vscode-languageclient/lib/protocolConverter";
+import { Range as ProtocolRange } from "vscode-languageserver-types";
 import { InlineKind, InlineVariable, resolveInlineVariables } from "./languageServerPlugin";
 
-const protoConverter: ProtocolConverter.Converter = ProtocolConverter.createConverter();
-const codeConverter: CodeConverter.Converter = CodeConverter.createConverter();
+export function toProtocolRange(range: Range): ProtocolRange {
+    return {
+        start: { line: range.start.line, character: range.start.character },
+        end: { line: range.end.line, character: range.end.character },
+    };
+}
+
+export function toCodeRange(range: ProtocolRange): Range {
+    return new Range(range.start.line, range.start.character, range.end.line, range.end.character);
+}
 
 export class JavaInlineValuesProvider implements InlineValuesProvider {
 
@@ -18,8 +25,8 @@ export class JavaInlineValuesProvider implements InlineValuesProvider {
             const resolveInlineVariablesStep = instrumentOperationStep(operationId, "resolveInlineVariables", async () => {
                 return <InlineVariable[]> (await resolveInlineVariables({
                     uri: document.uri.toString(),
-                    viewPort: codeConverter.asRange(viewPort),
-                    stoppedLocation: codeConverter.asRange(context.stoppedLocation),
+                    viewPort: toProtocolRange(viewPort),
+                    stoppedLocation: toProtocolRange(context.stoppedLocation),
                 }));
             });
             const variables: InlineVariable[] = await resolveInlineVariablesStep();
@@ -57,16 +64,16 @@ export class JavaInlineValuesProvider implements InlineValuesProvider {
                 let next = 0;
                 for (const variable of variables) {
                     if (variable.kind === InlineKind.VariableLookup) {
-                        result.push(new InlineValueVariableLookup(protoConverter.asRange(variable.range), variable.name, true));
+                        result.push(new InlineValueVariableLookup(toCodeRange(variable.range), variable.name, true));
                     } else if (resolvedVariables && resolvedVariables.length > next) {
                         const resolvedValue = resolvedVariables[next++];
                         if (resolvedValue) {
-                            result.push(new InlineValueText(protoConverter.asRange(variable.range), `${variable.name} = ${resolvedValue.value}`));
+                            result.push(new InlineValueText(toCodeRange(variable.range), `${variable.name} = ${resolvedValue.value}`));
                         } else {
-                            result.push(new InlineValueEvaluatableExpression(protoConverter.asRange(variable.range), variable.name));
+                            result.push(new InlineValueEvaluatableExpression(toCodeRange(variable.range), variable.name));
                         }
                     } else {
-                        result.push(new InlineValueEvaluatableExpression(protoConverter.asRange(variable.range), variable.name));
+                        result.push(new InlineValueEvaluatableExpression(toCodeRange(variable.range), variable.name));
                     }
                 }
 

src/JavaInlineValueProvider.ts

@@ -0,0 +1,20 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as assert from "assert";
+import { Range } from "vscode";
+
+import { toCodeRange, toProtocolRange } from "../src/JavaInlineValueProvider";
+
+suite("JavaInlineValueProvider", () => {
+    test("converts ranges without relying on language client internals", () => {
+        const codeRange = new Range(1, 2, 3, 4);
+        const protocolRange = toProtocolRange(codeRange);
+
+        assert.deepStrictEqual(protocolRange, {
+            start: { line: 1, character: 2 },
+            end: { line: 3, character: 4 },
+        });
+        assert.ok(toCodeRange(protocolRange).isEqual(codeRange));
+    });
+});

test/JavaInlineValueProvider.test.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+import * as assert from "assert";
+import * as Mocha from "mocha";
+
+import { run } from "./suite";
+
+suite("test runner", () => {
+    test("rejects when Mocha throws synchronously", async () => {
+        const expectedError = new Error("Mocha failed to start");
+        const originalRun = Mocha.prototype.run;
+        Mocha.prototype.run = () => {
+            throw expectedError;
+        };
+
+        try {
+            await assert.rejects(run(), (error) => error === expectedError);
+        } finally {
+            Mocha.prototype.run = originalRun;
+        }
+    });
+});