Several corrections

Author: jneira

package-lock.json

@@ -47,9 +47,8 @@ export async function activate(context: ExtensionContext) {
       const client = clients.get(folder.uri.toString());
       if (client) {
         const uri = folder.uri.toString();
-        client.info('Deleting folder for clients: ${uri}');
+        client.info(`Deleting folder for clients: ${uri}`);
         clients.delete(uri);
-        client.info;
         client.info('Stopping the client');
         client.stop();
       }
@@ -103,26 +102,26 @@ function findManualExecutable(logger: Logger, uri: Uri, folder?: WorkspaceFolder
   if (exePath === '') {
     return null;
   }
-  logger.info('Trying to find the server executable in: ${exePath}');
+  logger.info(`Trying to find the server executable in: ${exePath}`);
   // Substitute path variables with their corresponding locations.
   exePath = exePath.replace('${HOME}', os.homedir).replace('${home}', os.homedir).replace(/^~/, os.homedir);
   if (folder) {
     exePath = exePath.replace('${workspaceFolder}', folder.uri.path).replace('${workspaceRoot}', folder.uri.path);
   }
-  logger.info('Location after path variables subsitution: ${exePath}');
+  logger.info(`Location after path variables subsitution: ${exePath}`);
   if (!executableExists(exePath)) {
-    throw new Error(`serverExecutablePath is set to ${exePath} but it doesn't exist and is not on the PATH`);
+    throw new Error(`serverExecutablePath is set to ${exePath} but it doesn't exist and it is not on the PATH`);
   }
   return exePath;
 }
 
 /** Searches the PATH for whatever is set in serverVariant */
 function findLocalServer(context: ExtensionContext, logger: Logger, uri: Uri, folder?: WorkspaceFolder): string | null {
   const exes: string[] = ['haskell-language-server-wrapper', 'haskell-language-server'];
-  logger.info('Searching for server executables ${exes} in PATH');
+  logger.info(`Searching for server executables ${exes.join(' ')} in PATH`);
   for (const exe of exes) {
     if (executableExists(exe)) {
-      logger.info('Found server executable in PATH: ${exe}');
+      logger.info(`Found server executable in PATH: ${exe}`);
       return exe;
     }
   }
@@ -209,8 +208,8 @@ async function activateServerForFolder(context: ExtensionContext, uri: Uri, fold
     debug: { command: serverExecutable, transport: TransportKind.stdio, args, options: exeOptions },
   };
 
-  logger.info('run command: "' + serverExecutable + ' ' + args.join(' ') + '"');
-  logger.info('debug command: "' + serverExecutable + ' ' + args.join(' ') + '"');
+  logger.info(`run command: ${serverExecutable} ${args.join(' ')}`);
+  logger.info(`debug command: ${serverExecutable} ${args.join(' ')}`);
   logger.info(`server cwd: ${exeOptions.cwd}`);
 
   const pat = folder ? `${folder.uri.fsPath}/**/*` : '**/*';

src/extension.ts

@@ -110,27 +110,27 @@ async function getProjectGhcVersion(
     return window.withProgress(
       {
         location: ProgressLocation.Notification,
-        title: title,
+        title: `${title}`,
         cancellable: true,
       },
       async (progress, token) => {
         return new Promise<string>((resolve, reject) => {
           const command: string = wrapper + ' --project-ghc-version';
-          logger.info('Executing `${command}` in cwd ${dir} to get the project ghc version');
+          logger.info(`Executing '${command}' in cwd ${dir} to get the project ghc version`);
           token.onCancellationRequested(() => {
-            logger.warn('User canceled the executon of `${command}`');
+            logger.warn(`User canceled the executon of '${command}'`);
           });
           // Need to set the encoding to 'utf8' in order to get back a string
           // We execute the command in a shell for windows, to allow use cmd or bat scripts
-          let childProcess = child_process
+          const childProcess = child_process
             .execFile(
               command,
-              { encoding: 'utf8', cwd: dir, shell: getGithubOS() == 'Windows' },
+              { encoding: 'utf8', cwd: dir, shell: getGithubOS() === 'Windows' },
               (err, stdout, stderr) => {
                 if (err) {
-                  logger.error('Error executing `${command}` with error code ${err.code}');
-                  logger.error('stderr: ${stderr}');
-                  logger.error('stdout: ${stdout}');
+                  logger.error(`Error executing '${command}' with error code ${err.code}`);
+                  logger.error(`stderr: ${stderr}`);
+                  logger.error(`stdout: ${stdout}`);
                   const regex = /Cradle requires (.+) but couldn't find it/;
                   const res = regex.exec(stderr);
                   if (res) {
@@ -144,10 +144,10 @@ async function getProjectGhcVersion(
               }
             )
             .on('close', (code, signal) => {
-              logger.info('Execution of `${command}` closed with code ${err.code} and signal ${signal}');
+              logger.info(`Execution of '${command}' closed with code ${code} and signal ${signal}`);
             })
             .on('error', (err) => {
-              logger.error('Error execution `${command}`: name = ${err.name}, message = ${err.message}');
+              logger.error(`Error executing '${command}': name = ${err.name}, message = ${err.message}`);
               throw err;
             });
           token.onCancellationRequested((_) => childProcess.kill());
@@ -305,8 +305,8 @@ export async function downloadHaskellLanguageServer(
     window.showErrorMessage(message);
     return null;
   }
-  logger.info('The latest release is ${release.tag_name}');
-  logger.info('Figure out the ghc version to use or advertise an installation link for missing components');
+  logger.info(`The latest release is ${release.tag_name}`);
+  logger.info(`Figure out the ghc version to use or advertise an installation link for missing components`);
   const dir: string = folder?.uri?.fsPath ?? path.dirname(resource.fsPath);
   let ghcVersion: string;
   try {
@@ -333,10 +333,12 @@ export async function downloadHaskellLanguageServer(
   // When searching for binaries, use startsWith because the compression may differ
   // between .zip and .gz
   const assetName = `haskell-language-server-${githubOS}-${ghcVersion}${exeExt}`;
-  logger.info('Search for binary ${assetName} in release assests');
+  logger.info(`Search for binary ${assetName} in release assests`);
   const asset = release?.assets.find((x) => x.name.startsWith(assetName));
   if (!asset) {
-    logger.error('No binary ${assetName} found in the release assets: ' + release?.assets.map((value) => value.name));
+    logger.error(
+      `No binary ${assetName} found in the release assets: ${release?.assets.map((value) => value.name).join(',')}`
+    );
     window.showInformationMessage(new NoBinariesError(release.tag_name, ghcVersion).message);
     return null;
   }
@@ -348,7 +350,7 @@ export async function downloadHaskellLanguageServer(
   logger.info(title);
   await downloadFile(title, asset.browser_download_url, binaryDest);
   if (ghcVersion.startsWith('9.')) {
-    let warning =
+    const warning =
       'Currently, HLS supports GHC 9 only partially. ' +
       'See [issue #297](https://github.com/haskell/haskell-language-server/issues/297) for more detail.';
     logger.warn(warning);

src/hlsBinaries.ts

@@ -28,23 +28,26 @@ export class ExtensionLogger implements Logger {
     this.level = this.getLogLevel(level);
     this.channel = channel;
   }
-  warn(message: string): void {
+  public warn(message: string): void {
     this.logLevel(LogLevel.Warn, message);
   }
-  info(message: string): void {
+
+  public info(message: string): void {
     this.logLevel(LogLevel.Info, message);
   }
 
-  error(message: string) {
+  public error(message: string) {
     this.logLevel(LogLevel.Error, message);
   }
 
-  log(msg: string) {
+  public log(msg: string) {
     this.channel.appendLine(msg);
   }
 
   private logLevel(level: LogLevel, msg: string) {
-    if (level <= this.level) this.log('[${name}][${level}] ${msg}');
+    if (level <= this.level) {
+      this.log(`[${this.name}][${level}] ${msg}`);
+    }
   }
 
   private getLogLevel(level: string) {