tsconfig.json: noUnusedLocals, noFallThroughCaseInSwitch, tslint.json: promise-function-async

src/assets.ts

@@ -295,8 +295,8 @@ function hasAddOperations(operations: Operations) {
     return operations.addLaunchJson || operations.addLaunchJson;
 }
 
-function getOperations(generator: AssetGenerator) {
-    return getBuildOperations(generator.tasksJsonPath).then(operations =>
+async function getOperations(generator: AssetGenerator) {
+    return getBuildOperations(generator.tasksJsonPath).then(async operations =>
         getLaunchOperations(generator.launchJsonPath, operations));
 }
 
@@ -343,7 +343,7 @@ function getBuildTasks(tasksConfiguration: tasks.TaskConfiguration): tasks.TaskD
     return result;
 }
 
-function getBuildOperations(tasksJsonPath: string) {
+async function getBuildOperations(tasksJsonPath: string) {
     return new Promise<Operations>((resolve, reject) => {
         fs.exists(tasksJsonPath, exists => {
             if (exists) {
@@ -375,7 +375,7 @@ function getBuildOperations(tasksJsonPath: string) {
     });
 }
 
-function getLaunchOperations(launchJsonPath: string, operations: Operations) {
+async function getLaunchOperations(launchJsonPath: string, operations: Operations) {
     return new Promise<Operations>((resolve, reject) => {
         return fs.exists(launchJsonPath, exists => {
             if (exists) {
@@ -399,7 +399,7 @@ interface PromptItem extends vscode.MessageItem {
     result: PromptResult;
 }
 
-function promptToAddAssets(workspaceFolder: vscode.WorkspaceFolder) {
+async function promptToAddAssets(workspaceFolder: vscode.WorkspaceFolder) {
     return new Promise<PromptResult>((resolve, reject) => {
         const yesItem: PromptItem = { title: 'Yes', result: PromptResult.Yes };
         const noItem: PromptItem = { title: 'Not Now', result: PromptResult.No, isCloseAffordance: true };
@@ -413,7 +413,7 @@ function promptToAddAssets(workspaceFolder: vscode.WorkspaceFolder) {
     });
 }
 
-export function addTasksJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
+export async function addTasksJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
     return new Promise<void>((resolve, reject) => {
         if (!operations.addTasksJson) {
             return resolve();
@@ -443,7 +443,7 @@ function indentJsonString(json: string, numSpaces: number = 4): string {
     return json.split('\n').map(line => ' '.repeat(numSpaces) + line).join('\n').trim();
 }
 
-function addLaunchJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
+async function addLaunchJsonIfNecessary(generator: AssetGenerator, operations: Operations) {
     return new Promise<void>((resolve, reject) => {
         if (!operations.addLaunchJson) {
             return resolve();
@@ -489,7 +489,7 @@ function addLaunchJsonIfNecessary(generator: AssetGenerator, operations: Operati
     });
 }
 
-function addAssets(generator: AssetGenerator, operations: Operations) {
+async function addAssets(generator: AssetGenerator, operations: Operations) {
     const promises = [
         addTasksJsonIfNecessary(generator, operations),
         addLaunchJsonIfNecessary(generator, operations)
@@ -505,13 +505,13 @@ export enum AddAssetResult {
     Cancelled
 }
 
-export function addAssetsIfNecessary(server: OmniSharpServer): Promise<AddAssetResult> {
+export async function addAssetsIfNecessary(server: OmniSharpServer): Promise<AddAssetResult> {
     return new Promise<AddAssetResult>((resolve, reject) => {
         if (!vscode.workspace.workspaceFolders) {
             return resolve(AddAssetResult.NotApplicable);
         }
 
-        serverUtils.requestWorkspaceInformation(server).then(info => {
+        serverUtils.requestWorkspaceInformation(server).then(async info => {
             // If there are no .NET Core projects, we won't bother offering to add assets.
             if (protocol.containsDotNetCoreProjects(info)) {
                 const generator = new AssetGenerator(info);
@@ -541,7 +541,7 @@ export function addAssetsIfNecessary(server: OmniSharpServer): Promise<AddAssetR
     });
 }
 
-function doesAnyAssetExist(generator: AssetGenerator) {
+async function doesAnyAssetExist(generator: AssetGenerator) {
     return new Promise<boolean>((resolve, reject) => {
         fs.exists(generator.launchJsonPath, exists => {
             if (exists) {
@@ -556,14 +556,14 @@ function doesAnyAssetExist(generator: AssetGenerator) {
     });
 }
 
-function deleteAssets(generator: AssetGenerator) {
+async function deleteAssets(generator: AssetGenerator) {
     return Promise.all([
         util.deleteIfExists(generator.launchJsonPath),
         util.deleteIfExists(generator.tasksJsonPath)
     ]);
 }
 
-function shouldGenerateAssets(generator: AssetGenerator) {
+async function shouldGenerateAssets(generator: AssetGenerator) {
     return new Promise<boolean>((resolve, reject) => {
         doesAnyAssetExist(generator).then(res => {
             if (res) {

src/common.ts

@@ -35,13 +35,13 @@ export function safeLength<T>(arr: T[] | undefined) {
     return arr ? arr.length : 0;
 }
 
-export function buildPromiseChain<T, TResult>(array: T[], builder: (item: T) => Promise<TResult>): Promise<TResult> {
+export async function buildPromiseChain<T, TResult>(array: T[], builder: (item: T) => Promise<TResult>): Promise<TResult> {
     return array.reduce(
-        (promise, n) => promise.then(() => builder(n)),
+        async (promise, n) => promise.then(async () => builder(n)),
         Promise.resolve<TResult>(null));
 }
 
-export function execChildProcess(command: string, workingDirectory: string = getExtensionPath()): Promise<string> {
+export async function execChildProcess(command: string, workingDirectory: string = getExtensionPath()): Promise<string> {
     return new Promise<string>((resolve, reject) => {
         cp.exec(command, { cwd: workingDirectory, maxBuffer: 500 * 1024 }, (error, stdout, stderr) => {
             if (error) {
@@ -57,7 +57,7 @@ export function execChildProcess(command: string, workingDirectory: string = get
     });
 }
 
-export function getUnixChildProcessIds(pid: number): Promise<number[]> {
+export async function getUnixChildProcessIds(pid: number): Promise<number[]> {
     return new Promise<number[]>((resolve, reject) => {
         let ps = cp.exec('ps -A -o ppid,pid', (error, stdout, stderr) =>
         {
@@ -92,7 +92,7 @@ export function getUnixChildProcessIds(pid: number): Promise<number[]> {
     });
 }
 
-export function fileExists(filePath: string): Promise<boolean> {
+export async function fileExists(filePath: string): Promise<boolean> {
     return new Promise<boolean>((resolve, reject) => {
         fs.stat(filePath, (err, stats) => {
             if (stats && stats.isFile()) {
@@ -105,9 +105,9 @@ export function fileExists(filePath: string): Promise<boolean> {
     });
 }
 
-export function deleteIfExists(filePath: string): Promise<void> {
+export async function deleteIfExists(filePath: string): Promise<void> {
     return fileExists(filePath)
-    .then((exists: boolean) => {
+    .then(async (exists: boolean) => {
         return new Promise<void>((resolve, reject) => {
             if (!exists) {
                 return resolve();
@@ -134,11 +134,11 @@ function getInstallFilePath(type: InstallFileType): string {
     return path.resolve(getExtensionPath(), installFile);
 }
 
-export function installFileExists(type: InstallFileType): Promise<boolean> {
+export async function installFileExists(type: InstallFileType): Promise<boolean> {
     return fileExists(getInstallFilePath(type));
 }
 
-export function touchInstallFile(type: InstallFileType): Promise<void> {
+export async function touchInstallFile(type: InstallFileType): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         fs.writeFile(getInstallFilePath(type), '', err => {
             if (err) {
@@ -151,7 +151,7 @@ export function touchInstallFile(type: InstallFileType): Promise<void> {
     });
 }
 
-export function deleteInstallFile(type: InstallFileType): Promise<void> {
+export async function deleteInstallFile(type: InstallFileType): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         fs.unlink(getInstallFilePath(type), err => {
             if (err) {

src/configurationProvider.ts

@@ -28,7 +28,7 @@ export class CSharpConfigurationProvider implements vscode.DebugConfigurationPro
      * Note: serverUtils.requestWorkspaceInformation only retrieves one folder for multi-root workspaces. Therefore, generator will be incorrect for all folders
      * except the first in a workspace. Currently, this only works if the requested folder is the same as the server's solution path or folder.
      */
-    private checkWorkspaceInformationMatchesWorkspaceFolder(folder: vscode.WorkspaceFolder | undefined): Promise<boolean> {
+    private async checkWorkspaceInformationMatchesWorkspaceFolder(folder: vscode.WorkspaceFolder | undefined): Promise<boolean> {
         const solutionPathOrFolder: string = this.server.getSolutionPathOrFolder();
 
         // Make sure folder, folder.uri, and solutionPathOrFolder are defined.
@@ -59,18 +59,18 @@ export class CSharpConfigurationProvider implements vscode.DebugConfigurationPro
 	 * Returns a list of initial debug configurations based on contextual information, e.g. package.json or folder.
 	 */
     provideDebugConfigurations(folder: vscode.WorkspaceFolder | undefined, token?: vscode.CancellationToken): vscode.ProviderResult<vscode.DebugConfiguration[]> {
-        return serverUtils.requestWorkspaceInformation(this.server).then(info => {
-            return this.checkWorkspaceInformationMatchesWorkspaceFolder(folder).then(workspaceMatches => { 
+        return serverUtils.requestWorkspaceInformation(this.server).then(async info => {
+            return this.checkWorkspaceInformationMatchesWorkspaceFolder(folder).then(async workspaceMatches => { 
                 const generator = new AssetGenerator(info);
                 if (workspaceMatches && containsDotNetCoreProjects(info)) {
                     const dotVscodeFolder: string = path.join(folder.uri.fsPath, '.vscode');
                     const tasksJsonPath: string = path.join(dotVscodeFolder, 'tasks.json');
 
                     // Make sure .vscode folder exists, addTasksJsonIfNecessary will fail to create tasks.json if the folder does not exist. 
-                    return fs.ensureDir(dotVscodeFolder).then(() => {
+                    return fs.ensureDir(dotVscodeFolder).then(async () => {
                         // Check to see if tasks.json exists.
                         return fs.pathExists(tasksJsonPath);
-                    }).then(tasksJsonExists => {
+                    }).then(async tasksJsonExists => {
                         // Enable addTasksJson if it does not exist.
                         return addTasksJsonIfNecessary(generator, {addTasksJson: !tasksJsonExists});
                     }).then(() => {

src/coreclr-debug/util.ts

@@ -58,7 +58,7 @@ export class CoreClrDebugUtil
         return this._installCompleteFilePath;
     }
 
-    public static writeEmptyFile(path: string) : Promise<void> {
+    public static async writeEmptyFile(path: string) : Promise<void> {
         return new Promise<void>((resolve, reject) => {
             fs.writeFile(path, '', (err) => {
                 if (err) {
@@ -78,7 +78,7 @@ export class CoreClrDebugUtil
     // is new enough for us. 
     // Returns: a promise that returns a DotnetInfo class
     // Throws: An DotNetCliError() from the return promise if either dotnet does not exist or is too old. 
-    public checkDotNetCli(): Promise<DotnetInfo>
+    public async checkDotNetCli(): Promise<DotnetInfo>
     {
         let dotnetInfo = new DotnetInfo();
 

src/features/codeActionProvider.ts

@@ -34,7 +34,7 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
         this._options = Options.Read();
     }
 
-    public provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.Command[]> {
+    public async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.Command[]> {
         if (this._options.disableCodeActions) {
             return;
         }
@@ -99,12 +99,12 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
                     arguments: [runRequest]
                 };
             });
-        }, (error) => {
+        }, async (error) => {
             return Promise.reject(`Problem invoking 'GetCodeActions' on OmniSharp server: ${error}`);
         });
     }
 
-    private _runCodeAction(req: protocol.V2.RunCodeActionRequest): Promise<any> {
+    private async _runCodeAction(req: protocol.V2.RunCodeActionRequest): Promise<any> {
 
         return serverUtils.runCodeAction(this._server, req).then(response => {
 
@@ -176,7 +176,7 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
                         })
                  : next;
                 }
-            }, (error) => {
+            }, async (error) => {
             return Promise.reject(`Problem invoking 'RunCodeAction' on OmniSharp server: ${error}`);
         });
     }

src/features/commands.ts

@@ -38,17 +38,17 @@ export default function registerCommands(server: OmniSharpServer, eventStream: E
     // register process picker for attach
     let attachItemsProvider = DotNetAttachItemsProviderFactory.Get();
     let attacher = new AttachPicker(attachItemsProvider);
-    let d6 = vscode.commands.registerCommand('csharp.listProcess', () => attacher.ShowAttachEntries());
+    let d6 = vscode.commands.registerCommand('csharp.listProcess', async () => attacher.ShowAttachEntries());
 
     // Register command for generating tasks.json and launch.json assets.
-    let d7 = vscode.commands.registerCommand('dotnet.generateAssets', () => generateAssets(server));
+    let d7 = vscode.commands.registerCommand('dotnet.generateAssets', async () => generateAssets(server));
 
     // Register command for remote process picker for attach
-    let d8 = vscode.commands.registerCommand('csharp.listRemoteProcess', (args) => RemoteAttachPicker.ShowAttachEntries(args));
+    let d8 = vscode.commands.registerCommand('csharp.listRemoteProcess', async (args) => RemoteAttachPicker.ShowAttachEntries(args));
 
     // Register command for adapter executable command.
-    let d9 = vscode.commands.registerCommand('csharp.coreclrAdapterExecutableCommand', (args) => getAdapterExecutionCommand(platformInfo, eventStream));
-    let d10 = vscode.commands.registerCommand('csharp.clrAdapterExecutableCommand', (args) => getAdapterExecutionCommand(platformInfo, eventStream));
+    let d9 = vscode.commands.registerCommand('csharp.coreclrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream));
+    let d10 = vscode.commands.registerCommand('csharp.clrAdapterExecutableCommand', async (args) => getAdapterExecutionCommand(platformInfo, eventStream));
 
     return vscode.Disposable.from(d1, d2, d3, d4, d5, d6, d7, d8, d9, d10);
 }
@@ -78,7 +78,7 @@ function pickProjectAndStart(server: OmniSharpServer) {
         return vscode.window.showQuickPick(targets, {
             matchOnDescription: true,
             placeHolder: `Select 1 of ${targets.length} projects`
-        }).then(launchTarget => {
+        }).then(async launchTarget => {
             if (launchTarget) {
                 return server.restart(launchTarget);
             }
@@ -93,7 +93,7 @@ interface Command {
 }
 
 function projectsToCommands(projects: protocol.ProjectDescriptor[], eventStream: EventStream): Promise<Command>[] {
-    return projects.map(project => {
+    return projects.map(async project => {
         let projectDirectory = project.Directory;
 
         return new Promise<Command>((resolve, reject) => {
@@ -109,7 +109,7 @@ function projectsToCommands(projects: protocol.ProjectDescriptor[], eventStream:
                 resolve({
                     label: `dotnet restore - (${project.Name || path.basename(project.Directory)})`,
                     description: projectDirectory,
-                    execute() {
+                    async execute() {
                         return dotnetRestore(projectDirectory, eventStream);
                     }
                 });
@@ -118,13 +118,13 @@ function projectsToCommands(projects: protocol.ProjectDescriptor[], eventStream:
     });
 }
 
-export function dotnetRestoreAllProjects(server: OmniSharpServer, eventStream: EventStream): Promise<void> {
+export async function dotnetRestoreAllProjects(server: OmniSharpServer, eventStream: EventStream): Promise<void> {
 
     if (!server.isRunning()) {
         return Promise.reject('OmniSharp server is not running.');
     }
 
-    return serverUtils.requestWorkspaceInformation(server).then(info => {
+    return serverUtils.requestWorkspaceInformation(server).then(async info => {
 
         let descriptors = protocol.getDotNetCoreProjectDescriptors(info);
 
@@ -144,13 +144,13 @@ export function dotnetRestoreAllProjects(server: OmniSharpServer, eventStream: E
     });
 }
 
-export function dotnetRestoreForProject(server: OmniSharpServer, filePath: string, eventStream: EventStream) {
+export async function dotnetRestoreForProject(server: OmniSharpServer, filePath: string, eventStream: EventStream) {
 
     if (!server.isRunning()) {
         return Promise.reject('OmniSharp server is not running.');
     }
 
-    return serverUtils.requestWorkspaceInformation(server).then(info => {
+    return serverUtils.requestWorkspaceInformation(server).then(async info => {
 
         let descriptors = protocol.getDotNetCoreProjectDescriptors(info);
 
@@ -166,7 +166,7 @@ export function dotnetRestoreForProject(server: OmniSharpServer, filePath: strin
     });
 }
 
-function dotnetRestore(cwd: string, eventStream: EventStream, filePath?: string) {
+async function dotnetRestore(cwd: string, eventStream: EventStream, filePath?: string) {
     return new Promise<void>((resolve, reject) => {
         eventStream.post(new CommandDotNetRestoreStart());
 

src/features/completionItemProvider.ts

@@ -23,7 +23,7 @@ export default class OmniSharpCompletionItemProvider extends AbstractSupport imp
         ';', '+', '-', '*', '/', '%', '&', '|', '^', '!',
         '~', '=', '<', '>', '?', '@', '#', '\'', '\"', '\\'];
 
-    public provideCompletionItems(document: TextDocument, position: Position, token: CancellationToken, context: CompletionContext): Promise<CompletionList> {
+    public async provideCompletionItems(document: TextDocument, position: Position, token: CancellationToken, context: CompletionContext): Promise<CompletionList> {
 
         let wordToComplete = '';
         let range = document.getWordRangeAtPosition(position);

src/features/definitionProvider.ts

@@ -20,7 +20,7 @@ export default class CSharpDefinitionProvider extends AbstractSupport implements
         this._definitionMetadataDocumentProvider = definitionMetadataDocumentProvider;
     }
 
-    public provideDefinition(document: TextDocument, position: Position, token: CancellationToken): Promise<Location> {
+    public async provideDefinition(document: TextDocument, position: Position, token: CancellationToken): Promise<Location> {
 
         let req = <GoToDefinitionRequest>createRequest(document, position);
         req.WantMetadata = true;

src/features/documentHighlightProvider.ts

@@ -11,7 +11,7 @@ import {DocumentHighlightProvider, DocumentHighlight, DocumentHighlightKind, Can
 
 export default class OmnisharpDocumentHighlightProvider extends AbstractSupport implements DocumentHighlightProvider {
 
-    public provideDocumentHighlights(resource: TextDocument, position: Position, token: CancellationToken): Promise<DocumentHighlight[]> {
+    public async provideDocumentHighlights(resource: TextDocument, position: Position, token: CancellationToken): Promise<DocumentHighlight[]> {
 
         let req = createRequest<protocol.FindUsagesRequest>(resource, position);
         req.OnlyThisFile = true;