Fix linter errors.

Author: sean-mcmanus

Extension/src/Debugger/lldb-dap-worker.ts

@@ -226,9 +226,16 @@ export async function findLldbDapImpl() {
 
     // Only run one search at a time, so if we are already searching, return that.
     searching = new ManualPromise<string | undefined>();
-    searchForLldbDap().then(result => {
-        searching!.resolve(result);
-        searching = undefined;
+    searchForLldbDap().then((result: string | undefined): void => {
+        if (searching) {
+            searching.resolve(result);
+            searching = undefined;
+        }
+    }).catch(error => {
+        if (searching) {
+            searching.reject(error);
+            searching = undefined;
+        }
     });
     return searching;
 }

Extension/src/Utility/Remoting/snare.ts

@@ -178,25 +178,29 @@ export function startRemoting(connection: Worker | MessagePort, endpoint: Endpoi
             let result: ManualPromise<any> | undefined;
             let payload: Payload | undefined;
             try {
-
-                ready ? ready = await ready : undefined;
-
+                if (ready) {
+                    await ready;
+                }
                 result = new ManualPromise<any>();
                 payload = { operation, parameters: sanitizeParameters(parameters), sequence: ++next };
                 results.set(payload.sequence, result);
 
                 connection.postMessage(payload);
             } catch (err) {
                 // If we can't post the message, then we need to reject the promise.
-                results.delete(payload!.sequence);
-                result!.reject(err);
+                if (payload) {
+                    results.delete(payload.sequence);
+                }
+                if (result) {
+                    result.reject(err);
+                }
             }
             return result;
         },
         notify: (operation: string, ...parameters: any[]) => {
             try {
                 if (ready) {
-                    ready.then(() => {
+                    void ready.then(() => {
                         ready = undefined;
                         connection.postMessage({ operation, parameters: sanitizeParameters(parameters), sequence: 0 });
                     });
@@ -295,15 +299,15 @@ function sanitizeParameters(parameters: any[]) {
  * @param p The value to check.
  * @returns True if the value is a reference object.
  */
-function isReference(p: any): p is reference {
+function isReference(p: any): p is Reference {
     return is.object(p) && 'identity' in p && 'kind' in p;
 }
 
 /**
  * Interface representing a reference to an object or function in another thread.
  * References are used to represent values that cannot be cloned.
  */
-interface reference {
+interface Reference {
     /** Unique identifier for the referenced object. */
     identity: number;
 
@@ -334,23 +338,23 @@ export function getByRef<T = any>(identity: number): T {
  * @param instance A Promise resolving to the object to reference.
  * @returns A Promise resolving to a reference object, or undefined if the value can't be referenced.
  */
-export function ref(instance: Promise<any>): Promise<reference | undefined>;
+export function ref(instance: Promise<any>): Promise<Reference | undefined>;
 
 /**
  * Creates a reference to an object or function that can be sent to another thread.
  *
  * @param instance The object to reference.
  * @returns A reference object, or undefined if the value can't be referenced.
  */
-export function ref(instance: any): reference | undefined;
+export function ref(instance: any): Reference | undefined;
 
 /**
  * Implementation of the ref function handling both synchronous and asynchronous cases.
  *
  * @param instance The object or Promise to reference.
  * @returns A reference object, a Promise to a reference object, or undefined.
  */
-export function ref(instance: any | Promise<any>): reference | undefined | Promise<reference | undefined> {
+export function ref(instance: any | Promise<any>): Reference | undefined | Promise<Reference | undefined> {
     if (is.promise(instance)) {
         return instance.then(ref);
     }

Extension/src/common-remote-safe.ts

@@ -27,10 +27,14 @@ import { is } from './Utility/System/guards';
 let remoteConnection: RemoteConnection | undefined;
 
 // In the main thread, grab the logger and localize functions directly.
-const logFn = isMainThread ? require('./logger').log : () => { };
-const noteFn = isMainThread ? require('./logger').note : () => { };
-const localizeFn = isMainThread ? require('./localization').localize : (info: { key: string; comment: string[] } | string, message: string, ...args: (string | number | boolean | undefined | null)[]) => message.replace(/\{(\d+)\}/g, (_, index) => String(args[Number(index)] ?? 'undefined'));
-const getOutputChannelLoggerFn = isMainThread ? require('./logger').getOutputChannelLogger : () => undefined;
+import { localize as localizationLocalize } from './localization';
+import * as logger from './logger';
+import { getOutputChannelLogger, note as loggerNote } from './logger';
+
+const logFn = isMainThread ? logger.log : () => { };
+const noteFn = isMainThread ? loggerNote : () => { };
+const localizeFn = isMainThread ? localizationLocalize : (info: { key: string; comment: string[] } | string, message: string, ...args: (string | number | boolean | undefined | null)[]) => message.replace(/\{(\d+)\}/g, (_, index) => String(args[Number(index)] ?? 'undefined'));
+const getOutputChannelLoggerFn = isMainThread ? getOutputChannelLogger : () => undefined;
 
 /**
  * Used when this is imported in a module running in a worker thread.
@@ -79,17 +83,17 @@ export function note(message: string | Promise<string>) {
  * @param message The message to localize.
  * @param args The arguments for the message.
  */
-export function localize(info: { key: string; comment: string[] } | string, message: string, ...args: (string | number | boolean | undefined | null)[]): Promise<string> | string {
-    return isMainThread ?
-        // main thread uses localize directly
-        localizeFn(info, message, ...args) :
-
-        // worker (non-main) thread requests localization via remote connection
-        remoteConnection?.request('localize', info, message, ...args) ||
-
-        // fallback to simple replacement if no remote connection is available
+export const localize: AsyncLocalizeFunc = (infoOrKey, message, ...args) => {
+    if (isMainThread) {
+        if (typeof infoOrKey === 'string') {
+            return localizeFn(infoOrKey, message, ...args);
+        } else {
+            return localizeFn(infoOrKey as LocalizeInfo, message, ...args);
+        }
+    }
+    return remoteConnection?.request('localize', infoOrKey, message, ...args) ??
         message.replace(/\{(\d+)\}/g, (_, index) => String(args[Number(index)] ?? 'undefined'));
-}
+};
 
 export function appendLineAtLevel(level: number, message: string | Promise<string>): void {
     if (is.promise(message)) {
@@ -168,10 +172,11 @@ export interface LocalizeInfo {
 }
 
 /** The type for the localize function for string localization, but can work asynchronously (can be called via remoting). */
-export interface AsyncLocalizeFunc {
-    (info: LocalizeInfo, message: string, ...args: (string | number | boolean | undefined | null)[]): string | Promise<string>;
-    (key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): string | Promise<string>;
-}
+export type AsyncLocalizeFunc = (
+    infoOrKey: LocalizeInfo | string,
+    message: string,
+    ...args: (string | number | boolean | undefined | null)[]
+) => string | Promise<string>;
 
 /**
  * A cancellation token is passed to an asynchronous or long running
@@ -436,7 +441,7 @@ export async function searchFolders(folders: string[], filename: string | RegExp
 
                     // If it is a file, check for a match.
                     case stats.isFile():
-                        if (nameMatches(item) && (predicate ? await predicate!(fullPath) : true)) {
+                        if (nameMatches(item) && (predicate ? await predicate(fullPath) : true)) {
                             return options.result ??= fullPath;
                         }
                         break;