Generate correct values into launch.json

Author: DustinCampbell

src/assets.ts

@@ -9,6 +9,9 @@ import * as fs from 'fs-extra-promise';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import * as tasks from 'vscode-tasks';
+import {OmnisharpServer} from './omnisharpServer';
+import * as serverUtils from './omnisharpUtils';
+import * as protocol from './protocol.ts'
 
 interface DebugConfiguration {
     name: string,
@@ -125,26 +128,26 @@ function promptToAddAssets() {
     });
 }
 
-function createLaunchConfiguration(): ConsoleLaunchConfiguration {
+function createLaunchConfiguration(targetFramework: string, executableName: string): ConsoleLaunchConfiguration {
     return {
         name: '.NET Core Launch (console)',
         type: 'coreclr',
         request: 'launch',
         preLaunchTask: 'build',
-        program: '${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>',
+        program: '${workspaceRoot}/bin/Debug/' + targetFramework + '/'+ executableName,
         args: [],
         cwd: '${workspaceRoot}',
         stopAtEntry: false
     }
 }
 
-function createWebLaunchConfiguration(): WebLaunchConfiguration {
+function createWebLaunchConfiguration(targetFramework: string, executableName: string): WebLaunchConfiguration {
     return {
         name: '.NET Core Launch (web)',
         type: 'coreclr',
         request: 'launch',
         preLaunchTask: 'build',
-        program: '${workspaceRoot}/bin/Debug/<target-framework>/<project-name.dll>',
+        program: '${workspaceRoot}/bin/Debug/' + targetFramework + '/'+ executableName,
         args: [],
         cwd: '${workspaceRoot}',
         stopAtEntry: false,
@@ -167,19 +170,19 @@ function createWebLaunchConfiguration(): WebLaunchConfiguration {
 
 function createAttachConfiguration(): AttachConfiguration {
     return {
-        name: '.NET Core Attack',
+        name: '.NET Core Attach',
         type: 'coreclr',
         request: 'attach',
         processName: '<example>'
     }
 }
 
-function createLaunchJson(): any {
+function createLaunchJson(targetFramework: string, executableName: string): any {
     return {
         version: '0.2.0',
         configurations: [
-            createLaunchConfiguration(),
-            createWebLaunchConfiguration(),
+            createLaunchConfiguration(targetFramework, executableName),
+            createWebLaunchConfiguration(targetFramework, executableName),
             createAttachConfiguration()
         ]
     }
@@ -204,7 +207,7 @@ function createTasksConfiguration(): tasks.TaskConfiguration {
     };
 }
 
-function addTasksJsonIfNecessary(paths: Paths, operations: Operations) {
+function addTasksJsonIfNecessary(info: protocol.DotNetWorkspaceInformation, paths: Paths, operations: Operations) {
     return new Promise<void>((resolve, reject) => {
         if (!operations.addTasksJson) {
             return resolve();
@@ -217,66 +220,63 @@ function addTasksJsonIfNecessary(paths: Paths, operations: Operations) {
     });
 }
 
-function updateTasksJsonIfNecesssary(paths: Paths, operations: Operations) {
+function addLaunchJsonIfNecessary(info: protocol.DotNetWorkspaceInformation, paths: Paths, operations: Operations) {
     return new Promise<void>((resolve, reject) => {
-        if (!operations.updateTasksJson) {
+        if (!operations.addLaunchJson) {
             return resolve();
         }
 
-        return fs.readFileAsync(paths.tasksJsonPath).then(buffer => {
-            const bufferText = buffer.toString();
-            const tasksJson: tasks.TaskConfiguration = JSON.parse(bufferText);
-            tasksJson.tasks.push(createBuildTaskDescription());
-            const tasksJsonText = JSON.stringify(tasksJson, null, '    ');
-            
-            return fs.writeFileAsync(paths.tasksJsonPath, tasksJsonText);
-        });
-    });
-}
+        let targetFramework = '<target-framework>';
+        let executableName = '<project-name.dll>';
+        
+        let projectWithEntryPoint = info.Projects.find(project => project.EmitEntryPoint === true);
 
-function addLaunchJsonIfNecessary(paths: Paths, operations: Operations) {
-    return new Promise<void>((resolve, reject) => {
-        if (!operations.addLaunchJson) {
-            return resolve();
+        if (projectWithEntryPoint) {
+            targetFramework = projectWithEntryPoint.TargetFramework.ShortName;
+            executableName = path.basename(projectWithEntryPoint.CompilationOutputAssemblyFile);
         }
 
-        const launchJson = createLaunchJson();
+        const launchJson = createLaunchJson(targetFramework, executableName);
         const launchJsonText = JSON.stringify(launchJson, null, '    ');
 
         return fs.writeFileAsync(paths.launchJsonPath, launchJsonText);
     });
 }
 
-export function addAssetsIfNecessary() {
+export function addAssetsIfNecessary(server: OmnisharpServer) {
     if (!vscode.workspace.rootPath) {
         return;
     }
 
-    // If there is no project.json, we won't bother to prompt the user for tasks.json.
-    const projectJsonPath = path.join(vscode.workspace.rootPath, 'project.json');
+    // If there is no project.json, we won't bother to prompt the user for tasks.json.		
+    const projectJsonPath = path.join(vscode.workspace.rootPath, 'project.json');		
     if (!fs.existsSync(projectJsonPath)) {
         return;
     }
-    
-    return getOperations().then(operations => {
-        if (!hasOperations(operations)) {
-            return;
-        }
-        
-        promptToAddAssets().then(addAssets => {
-            if (!addAssets) {
-                return;
-            }
-            
-            const paths = getPaths();
-            
-            return fs.ensureDirAsync(paths.vscodeFolder).then(() => {
-                return Promise.all([
-                    addTasksJsonIfNecessary(paths, operations),
-                    updateTasksJsonIfNecesssary(paths, operations),
-                    addLaunchJsonIfNecessary(paths, operations)
-                ]);
+
+    return serverUtils.requestWorkspaceInformation(server).then(info => {
+        // If there are no .NET Core projects, we won't bother offering to add assets.
+        if ('DotNet' in info && info.DotNet.Projects.length > 0) {        
+            return getOperations().then(operations => {
+                if (!hasOperations(operations)) {
+                    return;
+                }
+                
+                promptToAddAssets().then(addAssets => {
+                    if (!addAssets) {
+                        return;
+                    }
+                    
+                    const paths = getPaths();
+                    
+                    return fs.ensureDirAsync(paths.vscodeFolder).then(() => {
+                        return Promise.all([
+                            addTasksJsonIfNecessary(info.DotNet, paths, operations),
+                            addLaunchJsonIfNecessary(info.DotNet, paths, operations)
+                        ]);
+                    });
+                });
             });
-        });
+        }
     });
 }

src/omnisharpMain.ts

@@ -74,6 +74,11 @@ export function activate(context: vscode.ExtensionContext): any {
 
 	disposables.push(registerCommands(server, context.extensionPath));
 	disposables.push(reportStatus(server));
+    
+    disposables.push(server.onServerStart(() => {
+        // Update or add tasks.json and launch.json
+        addAssetsIfNecessary(server);
+    }));
 
 	// read and store last solution or folder path
 	disposables.push(server.onBeforeServerStart(path => context.workspaceState.update('lastSolutionPathOrFolder', path)));
@@ -86,9 +91,6 @@ export function activate(context: vscode.ExtensionContext): any {
 		server.stop();
 	}));
 
-    // Update or add tasks.json and launch.json
-    addAssetsIfNecessary();
-    
     // install coreclr-debug
     installCoreClrDebug(context, reporter);
 

src/omnisharpServer.ts

@@ -268,8 +268,8 @@ export abstract class OmnisharpServer {
 			this._serverProcess = value.process;
             this._requestDelays = {};
             this._fireEvent(Events.StdOut, `[INFO] Started OmniSharp from '${value.command}' with process id ${value.process.pid}...\n`);
-            this._fireEvent(Events.ServerStart, solutionPath);
 			this._setState(ServerState.Started);
+            this._fireEvent(Events.ServerStart, solutionPath);
 			return this._doConnect();
 		}).then(_ => {
 			this._processQueue();

src/protocol.ts

@@ -268,12 +268,20 @@ export interface DotNetWorkspaceInformation {
 export interface DotNetProject {
 	Path: string;
     Name: string;
+    TargetFramework: DotNetFramework;
     CompilationOutputPath: string;
     CompilationOutputAssemblyFile: string;
     CompilationOutputPdbFile: string;
+    EmitEntryPoint?: boolean;
 	SourceFiles: string[];
 }
 
+export interface DotNetFramework {
+	Name: string;
+	FriendlyName: string;
+	ShortName: string;
+}
+
 export interface RenameRequest extends Request {
 	RenameTo: string;
 	WantsTextChanges?: boolean;