refactor: use logger instead of LOG

Author: weirongxu

.eslintrc

@@ -0,0 +1,7 @@
+{
+  "root": true,
+  "extends": ["@raidou/eslint-config-base"],
+  "env": {
+    "es6": true
+  }
+}

.eslintrc.json

@@ -125,13 +125,13 @@
     "prepare": "npm run build"
   },
   "devDependencies": {
+    "@raidou/eslint-config-base": "^1.5.0",
     "@types/node": "^17.0.18",
     "@types/semver": "^7.3.9",
-    "@typescript-eslint/eslint-plugin": "^5.12.0",
-    "@typescript-eslint/parser": "^5.12.0",
     "coc-helper": "^0.13.0",
     "coc.nvim": "^0.0.81-next.3",
     "eslint": "^8.9.0",
+    "prettier": "^2.5.1",
     "ts-loader": "^9.2.6",
     "typescript": "^4.5.5",
     "webpack": "^5.69.1",

.prettierrc.json renamed to .prettierrc

@@ -4,7 +4,7 @@ import path from 'path';
 import { InternalConfigManager } from './internalConfig';
 import { activateLanguageServer } from './languageSetup';
 import { fsExists } from './util/fsUtils';
-import { LOG, logger } from './util/logger';
+import { logger } from './util/logger';
 import { Status, StatusBarEntry } from './util/status';
 
 // this method is called when your extension is activated
@@ -44,7 +44,7 @@ export async function activate(context: ExtensionContext): Promise<void> {
       }),
     );
   } else {
-    LOG.info(
+    logger.info(
       "Skipping language server activation since 'kotlin.languageServer.enabled' is false",
     );
   }

package.json

@@ -28,7 +28,7 @@ export class JarClassContentProvider implements TextDocumentContentProvider {
     if (!result) {
       // eslint-disable-next-line no-restricted-properties
       window.showMessage(
-        `Could not fetch class file contents of '${uri}' from the language server. Make sure that it conforms to the format 'kls:file:///path/to/myJar.jar!/path/to/myClass.class'!`,
+        `Could not fetch class file contents of '${uri.toString()}' from the language server. Make sure that it conforms to the format 'kls:file:///path/to/myJar.jar!/path/to/myClass.class'!`,
         'error',
       );
       return '';

src/extension.ts

@@ -19,7 +19,7 @@ import path from 'path';
 import { JarClassContentProvider } from './jarClassContentProvider';
 import { ServerDownloader } from './serverDownloader';
 import { fsExists } from './util/fsUtils';
-import { LOG } from './util/logger';
+import { logger } from './util/logger';
 import { correctBinname, correctScriptName, isOSUnixoid } from './util/osUtils';
 import { Status } from './util/status';
 
@@ -29,7 +29,7 @@ export async function activateLanguageServer(
   status: Status,
   config: WorkspaceConfiguration,
 ) {
-  LOG.info('Activating Kotlin Language Server...');
+  logger.info('Activating Kotlin Language Server...');
   status.update('Activating Kotlin Language Server...');
 
   // Prepare language server
@@ -51,7 +51,9 @@ export async function activateLanguageServer(
       await langServerDownloader.downloadServerIfNeeded(status);
     } catch (error) {
       await window.showWarningMessage(
-        `Could not update/download Kotlin Language Server: ${error}`,
+        `Could not update/download Kotlin Language Server: ${(
+          error as Error
+        ).toString()}`,
       );
       return;
     }
@@ -66,7 +68,7 @@ export async function activateLanguageServer(
     return;
   }
 
-  const outputChannel = window.createOutputChannel('Kotlin');
+  const outputChannel = window.createOutputChannel('kotlin-language-server');
   context.subscriptions.push(outputChannel);
 
   const transportLayer = config.get('languageServer.transport');
@@ -76,11 +78,11 @@ export async function activateLanguageServer(
   if (transportLayer === 'tcp') {
     tcpPort = config.get<number>('languageServer.port')!;
 
-    LOG.info(`Connecting via TCP, port: ${tcpPort}`);
+    logger.info(`Connecting via TCP, port: ${tcpPort}`);
   } else if (transportLayer === 'stdio') {
-    LOG.info('Connecting via Stdio.');
+    logger.info('Connecting via Stdio.');
   } else {
-    LOG.info(`Unknown transport layer: ${transportLayer}`);
+    logger.info(`Unknown transport layer: ${transportLayer as string}`);
   }
 
   status.dispose();
@@ -107,17 +109,20 @@ export async function activateLanguageServer(
     workspace.registerTextDocumentContentProvider('kls:file', contentProvider),
   );
   context.subscriptions.push(
-    commands.registerCommand('kotlin.languageServer.restart', async () => {
-      await languageClient.stop();
-      languageClientDisposable.dispose();
-
-      outputChannel.appendLine('');
-      outputChannel.appendLine(' === Language Server Restart ===');
-      outputChannel.appendLine('');
-
-      languageClientDisposable = languageClient.start();
-      context.subscriptions.push(languageClientDisposable);
-    }),
+    commands.registerCommand(
+      'kotlin.languageServer.restart',
+      logger.asyncCatch(async () => {
+        await languageClient.stop();
+        languageClientDisposable.dispose();
+
+        outputChannel.appendLine('');
+        outputChannel.appendLine(' === Language Server Restart ===');
+        outputChannel.appendLine('');
+
+        languageClientDisposable = languageClient.start();
+        context.subscriptions.push(languageClientDisposable);
+      }),
+    ),
   );
 
   await languageClient.onReady();
@@ -176,7 +181,7 @@ function createLanguageClient(options: {
         env: options.env,
       }, // TODO: Support multi-root workspaces (and improve support for when no available is available)
     };
-    LOG.info('Creating client at {}', options.startScriptPath);
+    logger.info(`Creating client at ${options.startScriptPath}`);
   }
 
   return new LanguageClient(
@@ -193,9 +198,9 @@ export function spawnLanguageServerProcessAndConnectViaTcp(options: {
   tcpPort?: number;
 }): Promise<StreamInfo> {
   return new Promise((resolve, reject) => {
-    LOG.info('Creating server.');
+    logger.info('Creating server.');
     const server = net.createServer((socket) => {
-      LOG.info('Closing server since client has connected.');
+      logger.info('Closing server since client has connected.');
       server.close();
       resolve({ reader: socket, writer: socket });
     });
@@ -206,14 +211,12 @@ export function spawnLanguageServerProcessAndConnectViaTcp(options: {
         '--tcpClientPort',
         tcpPort,
       ]);
-      LOG.info(
-        'Creating client at {} via TCP port {}',
-        options.startScriptPath,
-        tcpPort,
+      logger.info(
+        `Creating client at ${options.startScriptPath} via TCP port ${tcpPort}`,
       );
 
       const outputCallback = (data: any) =>
-        options.outputChannel.append(`${data}`);
+        options.outputChannel.append(`${data as string}`);
       proc.stdout.on('data', outputCallback);
       proc.stderr.on('data', outputCallback);
       proc.on('exit', (code, sig) =>
@@ -233,7 +236,7 @@ async function findJavaExecutable(rawBinname: string): Promise<string> {
   const userJavaHome = workspace.getConfiguration('java').get<string>('home');
 
   if (userJavaHome) {
-    LOG.debug('Looking for Java in java.home (settings): {}', userJavaHome);
+    logger.debug(`Looking for Java in java.home (settings): ${userJavaHome}`);
 
     const candidate = await findJavaExecutableInJavaHome(userJavaHome, binname);
 
@@ -246,9 +249,8 @@ async function findJavaExecutable(rawBinname: string): Promise<string> {
   const envJavaHome = process.env['JAVA_HOME'];
 
   if (envJavaHome) {
-    LOG.debug(
-      'Looking for Java in JAVA_HOME (environment variable): {}',
-      envJavaHome,
+    logger.debug(
+      `Looking for Java in JAVA_HOME (environment variable): ${envJavaHome}`,
     );
 
     const candidate = await findJavaExecutableInJavaHome(envJavaHome, binname);
@@ -260,7 +262,7 @@ async function findJavaExecutable(rawBinname: string): Promise<string> {
 
   // Then search PATH parts
   if (process.env['PATH']) {
-    LOG.debug('Looking for Java in PATH');
+    logger.debug('Looking for Java in PATH');
 
     const pathparts = process.env['PATH'].split(path.delimiter);
     for (let i = 0; i < pathparts.length; i++) {
@@ -272,7 +274,7 @@ async function findJavaExecutable(rawBinname: string): Promise<string> {
   }
 
   // Else return the binary name directly (this will likely always fail downstream)
-  LOG.debug('Could not find Java, will try using binary name directly');
+  logger.debug('Could not find Java, will try using binary name directly');
   return binname;
 }
 
@@ -289,6 +291,4 @@ async function findJavaExecutableInJavaHome(
       return binpath;
     }
   }
-
-  return;
 }

src/jarClassContentProvider.ts

@@ -1,10 +1,7 @@
 import { TextDocumentIdentifier, RequestType } from 'coc.nvim';
 
 export namespace JarClassContentsRequest {
-  export const type = new RequestType<
-    TextDocumentIdentifier,
-    string,
-    void,
-    void
-  >('kotlin/jarClassContents');
+  export const type = new RequestType<TextDocumentIdentifier, string, void>(
+    'kotlin/jarClassContents',
+  );
 }

src/languageSetup.ts

@@ -4,7 +4,7 @@ import path from 'path';
 import semver from 'semver';
 import { GitHubReleasesAPIResponse } from './githubApi';
 import { fsExists } from './util/fsUtils';
-import { LOG } from './util/logger';
+import { logger } from './util/logger';
 import { Status } from './util/status';
 
 export interface ServerInfo {
@@ -50,8 +50,8 @@ export class ServerDownloader {
         (await fs.promises.readFile(this.serverInfoFile())).toString('utf8'),
       ) as ServerInfo;
       return semver.valid(info.version) ? info : undefined;
-    } catch {
-      return;
+    } catch (err) {
+      logger.warn((err as Error).toString());
     }
   }
 
@@ -95,21 +95,23 @@ export class ServerDownloader {
 
     if (secondsSinceLastUpdate > 480) {
       // Only query GitHub API for latest version if some time has passed
-      LOG.info(`Querying GitHub API for new ${this.displayName} version...`);
+      logger.info(`Querying GitHub API for new ${this.displayName} version...`);
 
       let releaseInfo: GitHubReleasesAPIResponse;
 
       try {
         releaseInfo = await this.latestReleaseInfo();
       } catch (error) {
-        const message = `Could not fetch from GitHub releases API: ${error}.`;
+        const message = `Could not fetch from GitHub releases API: ${(
+          error as Error
+        ).toString()}.`;
         if (serverInfo === undefined) {
           // No server is installed yet, so throw
           throw new Error(message);
         } else {
           // Do not throw since user might just be offline
           // and a version of the server is already installed
-          LOG.warn(message);
+          logger.warn(message);
           return;
         }
       }