Fix backslash escape, multiple linters output, .pyenv/versions folder search

src/client/common/markdown/restTextConverter.ts

@@ -36,7 +36,8 @@ export class RestTextConverter {
     return text
       .replace(/\#/g, '\\#')
       .replace(/\*/g, '\\*')
-      .replace(/\_/g, '\\_');
+      .replace(/\ _/g, ' \\_')
+      .replace(/^_/, '\\_');
   }
 
   private transformLines(docstring: string): string {

src/client/interpreter/locators/services/globalVirtualEnvService.ts

@@ -42,9 +42,11 @@ export class GlobalVirtualEnvironmentsSearchPathProvider implements IVirtualEnvi
             folders.push(pyenvRoot);
             folders.push(path.join(pyenvRoot, 'versions'));
         } else {
+            // Check if .pyenv/versions is in the list
             const pyenvVersions = path.join('.pyenv', 'versions');
             if (venvFolders.indexOf('.pyenv') >= 0 && venvFolders.indexOf(pyenvVersions) < 0) {
-                folders.push(pyenvVersions);
+                // if .pyenv is in the list, but .pyenv/versions is not, add it.
+                folders.push(path.join(homedir, pyenvVersions));
             }
         }
         return folders;

src/client/linters/linterCommands.ts

@@ -79,9 +79,9 @@ export class LinterCommands implements vscode.Disposable {
         }
     }
 
-    public runLinting(): void {
+    public runLinting(): Promise<vscode.DiagnosticCollection> {
         const engine = this.serviceContainer.get<ILintingEngine>(ILintingEngine);
-        engine.lintOpenPythonFiles();
+        return engine.lintOpenPythonFiles();
     }
 
     private get settingsUri(): vscode.Uri | undefined {

src/client/linters/lintingEngine.ts

@@ -51,32 +51,31 @@ export class LintingEngine implements ILintingEngine {
     this.diagnosticCollection = vscode.languages.createDiagnosticCollection('python');
   }
 
-  public lintOpenPythonFiles(): void {
-    this.documents.textDocuments.forEach(async document => {
+  public async lintOpenPythonFiles(): Promise<vscode.DiagnosticCollection> {
+    this.documents.textDocuments.forEach(document => {
       if (document.languageId === PythonLanguage.language) {
-        await this.lintDocument(document, 'auto');
+        this.lintDocument(document, 'auto').ignoreErrors();
       }
     });
+    return this.diagnosticCollection;
   }
 
-  public async lintDocument(document: vscode.TextDocument, trigger: LinterTrigger): Promise<void> {
+  public async lintDocument(document: vscode.TextDocument, trigger: LinterTrigger): Promise<vscode.DiagnosticCollection> {
     // Check if we need to lint this document
     const workspaceFolder = this.workspace.getWorkspaceFolder(document.uri);
     const workspaceRootPath = (workspaceFolder && typeof workspaceFolder.uri.fsPath === 'string') ? workspaceFolder.uri.fsPath : undefined;
     const relativeFileName = typeof workspaceRootPath === 'string' ? path.relative(workspaceRootPath, document.fileName) : document.fileName;
     const settings = this.configurationService.getSettings(document.uri);
     if (document.languageId !== PythonLanguage.language) {
-      return;
+      return this.diagnosticCollection;
     }
     if (!this.linterManager.isLintingEnabled(document.uri)) {
       this.diagnosticCollection.set(document.uri, []);
     }
-    const ignoreMinmatches = settings.linting.ignorePatterns.map(pattern => {
-      return new Minimatch(pattern);
-    });
 
+    const ignoreMinmatches = settings.linting.ignorePatterns.map(pattern => new Minimatch(pattern));
     if (ignoreMinmatches.some(matcher => matcher.match(document.fileName) || matcher.match(relativeFileName))) {
-      return;
+      return this.diagnosticCollection;
     }
 
     if (this.pendingLintings.has(document.uri.fsPath)) {
@@ -114,7 +113,6 @@ export class LintingEngine implements ILintingEngine {
         break;
       }
 
-      diagnostics = [];
       if (this.isDocumentOpen(document.uri)) {
         // Build the message and suffix the message with the name of the linter used.
         for (const m of msgs) {
@@ -123,17 +121,17 @@ export class LintingEngine implements ILintingEngine {
             (m.code === LinterErrors.pylint.InvalidSyntax ||
               m.code === LinterErrors.prospector.InvalidSyntax ||
               m.code === LinterErrors.flake8.InvalidSyntax)) {
-            return;
+            continue;
           }
           diagnostics.push(this.createDiagnostics(m, document));
         }
-
         // Limit the number of messages to the max value.
         diagnostics = diagnostics.filter((value, index) => index <= settings.linting.maxNumberOfProblems);
       }
-      // Set all diagnostics found in this pass, as this method always clears existing diagnostics.
-      this.diagnosticCollection.set(document.uri, diagnostics);
     }
+    // Set all diagnostics found in this pass, as this method always clears existing diagnostics.
+    this.diagnosticCollection.set(document.uri, diagnostics);
+    return this.diagnosticCollection;
   }
 
   // tslint:disable-next-line:no-any

src/client/linters/types.ts

@@ -61,8 +61,8 @@ export enum LintMessageSeverity {
 
 export const ILintingEngine = Symbol('ILintingEngine');
 export interface ILintingEngine {
-    lintOpenPythonFiles(): void;
-    lintDocument(document: vscode.TextDocument, trigger: LinterTrigger): Promise<void>;
+    lintOpenPythonFiles(): Promise<vscode.DiagnosticCollection>;
+    lintDocument(document: vscode.TextDocument, trigger: LinterTrigger): Promise<vscode.DiagnosticCollection>;
     // tslint:disable-next-line:no-any
     linkJupiterExtension(jupiter: vscode.Extension<any> | undefined): Promise<void>;
 }

src/test/interpreters/venv.test.ts

@@ -49,7 +49,7 @@ suite('Virtual environments', () => {
 
         let paths = pathProvider.getSearchPaths();
         let expected = folders.map(item => path.join(homedir, item));
-        expected.push(path.join('.pyenv', 'versions'));
+        expected.push(path.join(homedir, '.pyenv', 'versions'));
 
         expect(paths).to.deep.equal(expected, 'Global search folder list is incorrect.');
 

src/test/linters/lint.test.ts

@@ -8,7 +8,7 @@ import { Product } from '../../client/common/installer/productInstaller';
 import { IConfigurationService, IOutputChannel } from '../../client/common/types';
 import { LinterManager } from '../../client/linters/linterManager';
 import { ILinterManager, ILintMessage, LintMessageSeverity } from '../../client/linters/types';
-import { deleteFile, PythonSettingKeys, rootWorkspaceUri } from '../common';
+import { deleteFile, PythonSettingKeys, rootWorkspaceUri, sleep } from '../common';
 import { closeActiveWindows, initialize, initializeTest, IS_MULTI_ROOT_TEST } from '../initialize';
 import { MockOutputChannel } from '../mockClasses';
 import { UnitTestIocContainer } from '../unittests/serviceRegistry';
@@ -250,4 +250,29 @@ suite('Linting', () => {
         await configService.updateSettingAsync('linting.pylintUseMinimalCheckers', false, workspaceUri);
         await testEnablingDisablingOfLinter(Product.pylint, true, file);
     });
+    test('Multiple linters', async () => {
+        await linterManager.setActiveLintersAsync([Product.pylint, Product.flake8]);
+
+        const document = await vscode.workspace.openTextDocument(path.join(pythoFilesPath, 'print.py'));
+        const collection = await vscode.commands.executeCommand('python.runLinting') as vscode.DiagnosticCollection;
+        assert.notEqual(collection, undefined, 'python.runLinting did not return valid diagnostics collection.');
+
+        const ready = await waitForCondition(() => collection!.has(document.uri) && collection!.get(document.uri)!.length >= 3);
+        assert.equal(ready, true, 'Timeout expired but linting results are not available still.');
+
+        const messages = collection!.get(document.uri);
+        assert.notEqual(messages!.filter(x => x.source === 'pylint').length, 0, 'No pylint message.');
+        assert.notEqual(messages!.filter(x => x.source === 'flake8').length, 0, 'No flake8 message.');
+    });
+
+    async function waitForCondition(predicate: () => boolean, interval = 1000, maxAttempts = 10): Promise<boolean> {
+        return new Promise<boolean>(async (resolve) => {
+            let retries = 0;
+            while (!predicate() && retries < maxAttempts) {
+                await sleep(1000);
+                retries += 1;
+            }
+            resolve(retries < maxAttempts);
+        });
+    }
 });

src/test/pythonFiles/linting/print.py

@@ -0,0 +1 @@
+print x