Support more architectures and platforms in VS Code

* Change executable location to <arch>/<platform>/
* Add 'arm64' as a supported architecture
* Add initialization code that checks specific combinations of
  architectures and platforms (e.g. arm64-darwin is supported even
  though it actually uses the x64-darwin executable)

Author: eliericha

.github/workflows/build-binaries.sh

@@ -93,22 +93,23 @@ function fix_rpath ()
     install_name_tool -add_rpath @executable_path $1
 }
 
+# Get architecture and platform information from node.
+NODE_ARCH=$(node -e "console.log(process.arch)")
+NODE_PLATFORM=$(node -e "console.log(process.platform)")
+ALS_EXEC_DIR=integration/vscode/ada/$NODE_ARCH/$NODE_PLATFORM
+
 if [ $RUNNER_OS = macOS ]; then
-    cp -v -f /usr/local/opt/gmp/lib/libgmp.10.dylib integration/vscode/ada/darwin/
-    fix_rpath integration/vscode/ada/darwin/ada_language_server
+    cp -v -f /usr/local/opt/gmp/lib/libgmp.10.dylib $ALS_EXEC_DIR
+    fix_rpath $ALS_EXEC_DIR/ada_language_server
 fi
 
 if [ "$DEBUG" != "debug" ]; then
-    # Here it's better to match an exact extension rather than mathing
-    # ada_language_server* because when running locally, the latter could match
-    # ada_language_server.dSYM from a previous run if it exists.
+    cd $ALS_EXEC_DIR
     if [ $RUNNER_OS = Windows ]; then
-        ALS=`ls integration/vscode/ada/*/ada_language_server.exe`
+        ALS=ada_language_server.exe
     else
-        ALS=`ls integration/vscode/ada/*/ada_language_server`
+        ALS=ada_language_server
     fi
-    cd `dirname $ALS`
-    ALS=`basename ${ALS}`
     if [ $RUNNER_OS = macOS ]; then
         # On macOS using objcopy from binutils to strip debug symbols to a
         # separate file doesn't work. Namely, the last step `objcopy

.github/workflows/build-binaries.yml

@@ -107,7 +107,12 @@ jobs:
         uses: actions/upload-artifact@v3
         with:
           name: als-${{ runner.os }}-${{ matrix.debug }}
-          path: integration/vscode/ada/[ldw]*/*
+          # We know that only one of the following entries will match on a given
+          # run, so we use globs here to try to avoid warnings on unmatched
+          # entries
+          path: |
+            integration/vscode/ada/arm*
+            integration/vscode/ada/x64*
   package:
     if: ${{ github.event_name == 'push' }}
     needs: build

.github/workflows/pack-binaries.sh

@@ -18,8 +18,15 @@ function make_change_log()
 }
 
 chmod -R -v +x als-*-$DEBUG
-for X in Linux macOS Windows ; do mv -v -f als-$X-$DEBUG/* integration/vscode/ada/; done
-rm -rf -v integration/vscode/ada/{linux,darwin,win32}/*.{debug,dSYM}
+
+for X in Linux macOS Windows ; do
+    rsync -rva als-$X-$DEBUG/ integration/vscode/ada/
+done
+
+# VS Code is supported on arm, arm64 and x64 so we only consider those
+# architectures
+rm -rf -v integration/vscode/ada/{arm,arm64,x64}/{linux,darwin,win32}/*.{debug,dSYM}
+
 pushd integration/vscode/ada
 sed -i -e "/version/s/[0-9][0-9.]*/$TAG/" package.json
 [ -z "$DEBUG" ] || sed -i -e '/^    "name"/s/ada/ada-debug/' \
@@ -38,4 +45,4 @@ vsce package || true
 popd
 mv -v integration/vscode/ada/*.vsix .
 git checkout integration/vscode/ada/package.json
-rm -rf integration/vscode/ada/{linux,darwin,win32}
+rm -rf integration/vscode/ada/{arm,arm64,x64}/{linux,darwin,win32}

.gitignore

@@ -97,8 +97,16 @@ ENV/
 # Expected testsuite output
 testsuite/.als/inout.txt
 
-# Generated integration packages
+# Locations of ALS executable in VS Code extension. VS Code is supported on arm,
+# arm64 and x64 so we only consider those architectures.
+integration/vscode/ada/arm/
+integration/vscode/ada/arm64/
+integration/vscode/ada/x64/
+
+# Previous locations of ALS executable in VS Code extension
 integration/vscode/ada/linux/
+integration/vscode/ada/win32/
+integration/vscode/ada/darwin/
 
 # GNAT Studio clangd options
 .clang-format

Makefile

@@ -34,19 +34,27 @@ COVERAGE=
 COVERAGE_INSTR=gnatcov instrument --level stmt $(LIBRARY_FLAGS) \
 	--dump-trigger=atexit --no-subprojects
 
+ifeq (,$(shell which node))
+   # Node is not available so do not define node-related variables
+else
+   # Set NODE variable as an indicator that node is available
+   NODE=node
+   # Obtain architecture and platform from the node executable. This information
+   # is used to deposit the ALS executable at the location expected by the VS
+   # Code Ada extension.
+   NODE_ARCH=$(shell node -e "console.log(process.arch)")
+   NODE_PLATFORM=$(shell node -e "console.log(process.platform)")
+endif
+
 # Target platform as nodejs reports it
 ifeq ($(OS),Windows_NT)
-   PLATFORM=win32
    PYTHON=python.exe
    EXE=.exe
 else
    UNAME_S := $(shell uname -s)
    ifeq ($(UNAME_S),Linux)
-      PLATFORM=linux
       OS=unix
-   endif
-   ifeq ($(UNAME_S),Darwin)
-      PLATFORM=darwin
+   else ifeq ($(UNAME_S),Darwin)
       OS=osx
    endif
    PYTHON=python3
@@ -80,8 +88,10 @@ all: coverage-instrument
 	$(GPRBUILD) -P gnat/codec_test.gpr -p $(COVERAGE_BUILD_FLAGS)
 	$(GPRBUILD) -P gnat/lsp_client.gpr -p $(COVERAGE_BUILD_FLAGS) \
 		-XVERSION=$(VERSION)
-	mkdir -p integration/vscode/ada/$(PLATFORM)
-	cp -f $(ALS)$(EXE) integration/vscode/ada/$(PLATFORM)
+ifdef NODE
+	mkdir -p integration/vscode/ada/$(NODE_ARCH)/$(NODE_PLATFORM)
+	cp -f $(ALS)$(EXE) integration/vscode/ada/$(NODE_ARCH)/$(NODE_PLATFORM)
+endif
 
 generate:
 	python scripts/generate.py
@@ -119,7 +129,7 @@ clean:
 	-$(GPRCLEAN) -P gnat/lsp_server.gpr $(LIBRARY_FLAGS)
 	-$(GPRCLEAN) -P gnat/tester.gpr $(LIBRARY_FLAGS)
 	-$(GPRCLEAN) -P gnat/codec_test.gpr $(LIBRARY_FLAGS)
-	-rm -rf integration/vscode/ada/$(PLATFORM)
+	-rm -rf integration/vscode/ada/$(NODE_ARCH)/$(NODE_PLATFORM)
 
 vscode:
 ifneq ($(npm_config_offline),true)
@@ -151,4 +161,4 @@ check: all
 	${CODEC_TEST} < testsuite/codecs/index.txt
 
 deploy: check
-	integration/$(USER)/deploy.sh $(PLATFORM)
+	integration/$(USER)/deploy.sh $(NODE_PLATFORM)

integration/vscode/ada/package.json

@@ -38,6 +38,7 @@
         "darwin"
     ],
     "cpu": [
+        "arm64",
         "x64"
     ],
     "keywords": [

integration/vscode/ada/src/extension.ts

@@ -31,6 +31,7 @@ import { alsCommandExecutor } from './alsExecuteCommand';
 import GnatTaskProvider, { getEnclosingSymbol } from './gnatTaskProvider';
 import GprTaskProvider from './gprTaskProvider';
 import { getEvaluatedCustomEnv } from './helpers';
+import { existsSync } from 'fs';
 
 export let contextClients: ContextClients;
 export let mainLogChannel: vscode.OutputChannel;
@@ -114,6 +115,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     mainLogChannel = vscode.window.createOutputChannel('Ada Extension');
     mainLogChannel.appendLine('Starting Ada extension');
 
+    assertSupportedEnvironments();
+
     context.subscriptions.push(
         vscode.commands.registerCommand('ada.showExtensionOutput', () => mainLogChannel.show())
     );
@@ -182,8 +185,38 @@ function createClient(
     extra: string[],
     pattern: string
 ) {
-    let serverModule = context.asAbsolutePath(process.platform + '/ada_language_server');
-    if (process.env.ALS) serverModule = process.env.ALS;
+    let serverExecPath: string;
+
+    if (process.arch == 'arm64' && process.platform == 'darwin') {
+        // On arm64 darwin use the x64 darwin executable thanks to Apple Rosetta.
+        serverExecPath = context.asAbsolutePath(`x64/darwin/ada_language_server`);
+    } else {
+        serverExecPath = context.asAbsolutePath(
+            `${process.arch}/${process.platform}/ada_language_server`
+        );
+    }
+
+    // If the ALS environment variable is specified, use it as the path of the
+    // server executable.
+    if (process.env.ALS) {
+        serverExecPath = process.env.ALS;
+        if (!existsSync(serverExecPath)) {
+            logErrorAndThrow(
+                `The Ada language server given in the ALS environment ` +
+                    `variable does not exist: ${serverExecPath}`
+            );
+        }
+    } else {
+        if (!existsSync(serverExecPath)) {
+            logErrorAndThrow(
+                `This installation of the Ada extension does not have the Ada ` +
+                    `language server for your architecture (${process.arch}) ` +
+                    `and platform (${process.platform}) ` +
+                    `at the expected location: ${serverExecPath}`
+            );
+        }
+    }
+
     // The debug options for the server
     // let debugOptions = { execArgv: [] };
     // If the extension is launched in debug mode then the debug server options are used
@@ -203,8 +236,8 @@ function createClient(
 
     // Options to control the server
     const serverOptions: ServerOptions = {
-        run: { command: serverModule, args: extra },
-        debug: { command: serverModule, args: extra },
+        run: { command: serverExecPath, args: extra },
+        debug: { command: serverExecPath, args: extra },
     };
 
     // Options to control the language client
@@ -352,3 +385,32 @@ async function checkSrcDirectories(alsClient: LanguageClient) {
             });
     }
 }
+
+function assertSupportedEnvironments() {
+    type Env = {
+        arch: 'arm' | 'arm64' | 'x64';
+        platform: 'win32' | 'linux' | 'darwin';
+    };
+    const supportedEnvs: Env[] = [
+        { arch: 'x64', platform: 'linux' },
+        { arch: 'x64', platform: 'win32' },
+        { arch: 'x64', platform: 'darwin' },
+        { arch: 'arm64', platform: 'darwin' },
+    ];
+
+    if (
+        !supportedEnvs.some((val) => {
+            return val.arch == process.arch && val.platform == process.platform;
+        })
+    ) {
+        const msg =
+            `The Ada extension is not supported on ` +
+            `architecture '${process.arch}' and platform '${process.platform}'`;
+        logErrorAndThrow(msg);
+    }
+}
+
+function logErrorAndThrow(msg: string) {
+    mainLogChannel.appendLine('[Error] ' + msg);
+    throw new Error(msg);
+}