#1228 support multi roots in language service (#1309)

* update to use latest api

* config changes for multiroot workspace

* linting support with multi roots

* multi root support for formatters

* determine workspace root path

* revert change

* support multiple configs per workspace folder

* modify formatters to use resource specific settings

* modified installer to pass resource for workspace resolution

* null test in installer

* canges to config settings to support multiroot workspace

* changes to code refactoring to support workspace symbols

* oops

* modified to settings are resolved using document uri

* unit tests for multi root support

* fix unittests for multiroot

* exclude files

* add new line

* config changes for multiroot workspace

* new lines and enabled multi root linter tests

* fix sys variables

* added unit test to resolve ${workspaceRoot} in settings.json

* #1228 workspace symbols with multiroot support

* fix test

* added some data for workspace symbol tests

* data for unit tests

* fixed to add support for multit roots with unit tests

* account for mutiroot files in sub directory

* disable all but multiroot tests

* fixed tests

* fix tests

* test where failing

* properly determine root workspace

* fix pytest unit test

* delete files

* add awaiter

* use a path that works on multiple os

* fixes

* uncomment

* invert

* debug statements

* use default workspace

* reverted unwanted changes

* oops

* test unittests only

* more logging

* partial fixes to unit tests

* run all tests

* changes not to set paths for shebang tests

* remove comments

* update settings only if necessary

* fix test

* include files for tests

* Fixed travis tests for multi root workspace symbols (#1306)

* added logging

* more logging

* yay

* fixed

* more fixes

* fix tests

* removed logging

* enable all tests

* uncommented

* Added brackets around print statements (for p3)

* use resource when getting settings

* support multiroot in language services

Author: DonJayamanne

src/client/extension.ts

@@ -1,6 +1,7 @@
 'use strict';
 
 import * as vscode from 'vscode';
+import { JediFactory } from './languageServices/jediProxyFactory';
 import { PythonCompletionItemProvider } from './providers/completionProvider';
 import { PythonHoverProvider } from './providers/hoverProvider';
 import { PythonDefinitionProvider } from './providers/definitionProvider';
@@ -68,7 +69,8 @@ export async function activate(context: vscode.ExtensionContext) {
     context.subscriptions.push(activateUpdateSparkLibraryProvider());
     activateSimplePythonRefactorProvider(context, formatOutChannel);
     context.subscriptions.push(activateFormatOnSaveProvider(PYTHON, formatOutChannel));
-    context.subscriptions.push(activateGoToObjectDefinitionProvider(context));
+    const jediFactory = new JediFactory(context.asAbsolutePath('.'));
+    context.subscriptions.push(...activateGoToObjectDefinitionProvider(jediFactory));
 
     context.subscriptions.push(vscode.commands.registerCommand(Commands.Start_REPL, () => {
         getPathFromPythonCommand(["-c", "import sys;print(sys.executable)"]).catch(() => {
@@ -99,19 +101,19 @@ export async function activate(context: vscode.ExtensionContext) {
         ]
     });
 
+    context.subscriptions.push(jediFactory);
     context.subscriptions.push(vscode.languages.registerRenameProvider(PYTHON, new PythonRenameProvider(formatOutChannel)));
-    const definitionProvider = new PythonDefinitionProvider(context);
-    const jediProx = definitionProvider.JediProxy;
+    const definitionProvider = new PythonDefinitionProvider(jediFactory);
     context.subscriptions.push(vscode.languages.registerDefinitionProvider(PYTHON, definitionProvider));
-    context.subscriptions.push(vscode.languages.registerHoverProvider(PYTHON, new PythonHoverProvider(context, jediProx)));
-    context.subscriptions.push(vscode.languages.registerReferenceProvider(PYTHON, new PythonReferenceProvider(context, jediProx)));
-    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(PYTHON, new PythonCompletionItemProvider(context, jediProx), '.'));
+    context.subscriptions.push(vscode.languages.registerHoverProvider(PYTHON, new PythonHoverProvider(jediFactory)));
+    context.subscriptions.push(vscode.languages.registerReferenceProvider(PYTHON, new PythonReferenceProvider(jediFactory)));
+    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(PYTHON, new PythonCompletionItemProvider(jediFactory), '.'));
     context.subscriptions.push(vscode.languages.registerCodeLensProvider(PYTHON, new ShebangCodeLensProvider()))
 
-    const symbolProvider = new PythonSymbolProvider(context, jediProx);
+    const symbolProvider = new PythonSymbolProvider(jediFactory);
     context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(PYTHON, symbolProvider));
     if (pythonSettings.devOptions.indexOf('DISABLE_SIGNATURE') === -1) {
-        context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(PYTHON, new PythonSignatureProvider(context, jediProx), '(', ','));
+        context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(PYTHON, new PythonSignatureProvider(jediFactory), '(', ','));
     }
     if (pythonSettings.formatting.provider !== 'none') {
         const formatProvider = new PythonFormattingEditProvider(context, formatOutChannel);

src/client/jedi/main.ts

@@ -1,10 +1,10 @@
 "use strict";
 
-import { SocketClient } from './socketClient';
-import { SocketServer } from '../common/comms/socketServer';
 import * as child_process from 'child_process';
 import * as path from 'path';
 import * as vscode from 'vscode';
+import { SocketClient } from './socketClient';
+import { SocketServer } from '../common/comms/socketServer';
 import { createDeferred, Deferred } from '../common/helpers';
 import { PythonSettings } from '../common/configSettings';
 import { EventEmitter } from 'events';
@@ -80,7 +80,8 @@ export class ClientAdapter extends EventEmitter {
         this.startSocketServer().then(port => {
             const def = createDeferred<any>();
             const options = { env: newEnv, cwd: this.rootDir };
-            this.process = child_process.spawn(PythonSettings.getInstance().pythonPath, [pyFile, port.toString()], options);
+            const rootDirUri = this.rootDir ? vscode.Uri.file(this.rootDir) : undefined;
+            this.process = child_process.spawn(PythonSettings.getInstance(rootDirUri).pythonPath, [pyFile, port.toString()], options);
             this.process.stdout.setEncoding('utf8');
             this.process.stderr.setEncoding('utf8');
 

src/client/jedi/parsers/CompletionParser.ts

@@ -1,12 +1,10 @@
-import { CompletionItem, SymbolKind, SnippetString } from 'vscode';
 import * as proxy from '../../providers/jediProxy';
 import { extractSignatureAndDocumentation } from '../../providers/jediHelpers';
 import { PythonSettings } from '../../common/configSettings';
-
-const pythonSettings = PythonSettings.getInstance();
+import { CompletionItem, SymbolKind, SnippetString, Uri } from 'vscode';
 
 export class CompletionParser {
-    public static parse(data: proxy.ICompletionResult): CompletionItem[] {
+    public static parse(data: proxy.ICompletionResult, resource: Uri): CompletionItem[] {
         if (!data || data.items.length === 0) {
             return [];
         }
@@ -16,7 +14,7 @@ export class CompletionParser {
             completionItem.kind = item.type;
             completionItem.documentation = sigAndDocs[1].length === 0 ? item.description : sigAndDocs[1];
             completionItem.detail = sigAndDocs[0].split(/\r?\n/).join('');
-            if (pythonSettings.autoComplete.addBrackets === true &&
+            if (PythonSettings.getInstance(resource).autoComplete.addBrackets === true &&
                 (item.kind === SymbolKind.Function || item.kind === SymbolKind.Method)) {
                 completionItem.insertText = new SnippetString(item.text).appendText("(").appendTabstop().appendText(")");
             }

src/client/languageServices/jediProxyFactory.ts

@@ -0,0 +1,38 @@
+import { Disposable, Uri, workspace } from 'vscode';
+import { JediProxy, JediProxyHandler, ICommandResult } from '../providers/jediProxy';
+
+export class JediFactory implements Disposable {
+    private disposables: Disposable[];
+    private jediProxyHandlers: Map<string, JediProxyHandler<ICommandResult>>;
+
+    constructor(private extensionRootPath: string) {
+        this.disposables = [];
+        this.jediProxyHandlers = new Map<string, JediProxyHandler<ICommandResult>>();
+    }
+
+    public dispose() {
+        this.disposables.forEach(disposable => disposable.dispose());
+        this.disposables = [];
+    }
+    public getJediProxyHandler<T extends ICommandResult>(resource: Uri): JediProxyHandler<T> {
+        const workspaceFolder = workspace.getWorkspaceFolder(resource);
+        let workspacePath = workspaceFolder ? workspaceFolder.uri.fsPath : undefined;
+        if (!workspacePath) {
+            if (Array.isArray(workspace.workspaceFolders) && workspace.workspaceFolders.length > 0) {
+                workspacePath = workspace.workspaceFolders[0].uri.fsPath;
+            }
+            else {
+                workspacePath = __dirname;
+            }
+        }
+
+        if (!this.jediProxyHandlers.has(workspacePath)) {
+            const jediProxy = new JediProxy(this.extensionRootPath, workspacePath);
+            const jediProxyHandler = new JediProxyHandler(jediProxy);
+            this.disposables.push(jediProxy, jediProxyHandler);
+            this.jediProxyHandlers.set(workspacePath, jediProxyHandler);
+        }
+        // tslint:disable-next-line:no-non-null-assertion
+        return this.jediProxyHandlers.get(workspacePath)! as JediProxyHandler<T>;
+    }
+}

src/client/providers/completionProvider.ts

@@ -7,25 +7,21 @@ import * as telemetryContracts from '../common/telemetryContracts';
 import { extractSignatureAndDocumentation } from './jediHelpers';
 import { EOL } from 'os';
 import { PythonSettings } from '../common/configSettings';
-import { SnippetString } from 'vscode';
-
-const pythonSettings = PythonSettings.getInstance();
+import { SnippetString, Uri } from 'vscode';
+import { JediFactory } from '../languageServices/jediProxyFactory';
 
 export class PythonCompletionItemProvider implements vscode.CompletionItemProvider {
-    private jediProxyHandler: proxy.JediProxyHandler<proxy.ICompletionResult>;
 
-    public constructor(context: vscode.ExtensionContext, jediProxy: proxy.JediProxy = null) {
-        this.jediProxyHandler = new proxy.JediProxyHandler(context, jediProxy);
-    }
-    private static parseData(data: proxy.ICompletionResult): vscode.CompletionItem[] {
+    public constructor(private jediFactory: JediFactory) { }
+    private static parseData(data: proxy.ICompletionResult, resource: Uri): vscode.CompletionItem[] {
         if (data && data.items.length > 0) {
             return data.items.map(item => {
                 const sigAndDocs = extractSignatureAndDocumentation(item);
                 let completionItem = new vscode.CompletionItem(item.text);
                 completionItem.kind = item.type;
                 completionItem.documentation = sigAndDocs[1].length === 0 ? item.description : sigAndDocs[1];
                 completionItem.detail = sigAndDocs[0].split(/\r?\n/).join('');
-                if (pythonSettings.autoComplete.addBrackets === true &&
+                if (PythonSettings.getInstance(resource).autoComplete.addBrackets === true &&
                     (item.kind === vscode.SymbolKind.Function || item.kind === vscode.SymbolKind.Method)) {
                     completionItem.insertText = new SnippetString(item.text).appendText("(").appendTabstop().appendText(")");
                 }
@@ -67,10 +63,10 @@ export class PythonCompletionItemProvider implements vscode.CompletionItemProvid
         };
 
         const timer = new telemetryHelper.Delays();
-        return this.jediProxyHandler.sendCommand(cmd, token).then(data => {
+        return this.jediFactory.getJediProxyHandler<proxy.ICompletionResult>(document.uri).sendCommand(cmd, token).then(data => {
             timer.stop();
             telemetryHelper.sendTelemetryEvent(telemetryContracts.IDE.Completion, {}, timer.toMeasures());
-            const completions = PythonCompletionItemProvider.parseData(data);
+            const completions = PythonCompletionItemProvider.parseData(data, document.uri);
             return completions;
         });
     }

src/client/providers/definitionProvider.ts

@@ -2,17 +2,11 @@
 
 import * as vscode from 'vscode';
 import * as proxy from './jediProxy';
-import * as telemetryContracts from "../common/telemetryContracts";
+import * as telemetryContracts from '../common/telemetryContracts';
+import { JediFactory } from '../languageServices/jediProxyFactory';
 
 export class PythonDefinitionProvider implements vscode.DefinitionProvider {
-    private jediProxyHandler: proxy.JediProxyHandler<proxy.IDefinitionResult>;
-    public get JediProxy(): proxy.JediProxy {
-        return this.jediProxyHandler.JediProxy;
-    }
-
-    public constructor(context: vscode.ExtensionContext) {
-        this.jediProxyHandler = new proxy.JediProxyHandler(context);
-    }
+    public constructor(private jediFactory: JediFactory) { }
     private static parseData(data: proxy.IDefinitionResult, possibleWord: string): vscode.Definition {
         if (data && Array.isArray(data.definitions) && data.definitions.length > 0) {
             const definitions = data.definitions.filter(d => d.text === possibleWord);
@@ -46,7 +40,7 @@ export class PythonDefinitionProvider implements vscode.DefinitionProvider {
             cmd.source = document.getText();
         }
         let possibleWord = document.getText(range);
-        return this.jediProxyHandler.sendCommand(cmd, token).then(data => {
+        return this.jediFactory.getJediProxyHandler<proxy.IDefinitionResult>(document.uri).sendCommand(cmd, token).then(data => {
             return PythonDefinitionProvider.parseData(data, possibleWord);
         });
     }

src/client/providers/hoverProvider.ts

@@ -4,13 +4,10 @@ import * as vscode from 'vscode';
 import * as proxy from './jediProxy';
 import { highlightCode } from './jediHelpers';
 import { EOL } from 'os';
+import { JediFactory } from '../languageServices/jediProxyFactory';
 
 export class PythonHoverProvider implements vscode.HoverProvider {
-    private jediProxyHandler: proxy.JediProxyHandler<proxy.IHoverResult>;
-
-    public constructor(context: vscode.ExtensionContext, jediProxy: proxy.JediProxy = null) {
-        this.jediProxyHandler = new proxy.JediProxyHandler(context, jediProxy);
-    }
+    public constructor(private jediFactory: JediFactory) { }
     private static parseData(data: proxy.IHoverResult, currentWord: string): vscode.Hover {
         let results = [];
         let capturedInfo: string[] = [];
@@ -96,7 +93,7 @@ export class PythonHoverProvider implements vscode.HoverProvider {
             cmd.source = document.getText();
         }
 
-        const data = await this.jediProxyHandler.sendCommand(cmd, token);
+        const data = await this.jediFactory.getJediProxyHandler<proxy.IHoverResult>(document.uri).sendCommand(cmd, token);
         if (!data || !data.items.length) {
             return;
         }