Merge pull request #6391 from dibarbet/merge_main

Snap main to release

Author: dibarbet

CHANGELOG.md

@@ -8,6 +8,15 @@
 - Debug from .csproj and .sln [#5876](https://github.com/dotnet/vscode-csharp/issues/5876)
 
 ## Latest
+* Update Roslyn version (PR: [#6389](https://github.com/dotnet/vscode-csharp/pull/6389))
+  * Remove diagnostic source name (PR: [#69939](https://github.com/dotnet/roslyn/pull/69939))
+  * Fix fold all regions (PR: [#69817](https://github.com/dotnet/roslyn/pull/69817))
+  * Fix escaping and wrapping in hover (PR: [#69893](https://github.com/dotnet/roslyn/pull/69893))
+  * Fix error in override completion when containing type does not exist (PR: [#69855](https://github.com/dotnet/roslyn/pull/69855))
+* Fix issues generating assets in Omnisharp (PR: [#6380](https://github.com/dotnet/vscode-csharp/pull/6380))
+* Allow Razor to format new documents via Roslyn (PR: [#6329](https://github.com/dotnet/vscode-csharp/pull/6329))
+* Switch to named pipes for client <-> server communication (PR: [#6351](https://github.com/dotnet/vscode-csharp/pull/6351))
+* Only show clr debugger if on Windows (PR: [#6359](https://github.com/dotnet/vscode-csharp/pull/6359))
 * Update Razor version to 7.0.0-preview.23456.2 (PR: [#6304](https://github.com/dotnet/vscode-csharp/pull/6304))
   * Fixes regression where semantic colors for razor components appear as red
 * Make completion complex text edits more robust (PR: [#6325](https://github.com/dotnet/vscode-csharp/pull/6325))

gulpfile.ts

@@ -3,25 +3,9 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as gulp from 'gulp';
-import * as optionsSchemaGenerator from './src/tools/generateOptionsSchema';
-import * as packageDependencyUpdater from './src/tools/updatePackageDependencies';
-
 require('./tasks/testTasks');
 require('./tasks/offlinePackagingTasks');
 require('./tasks/backcompatTasks');
 require('./tasks/localizationTasks');
 require('./tasks/createTagsTasks');
-
-// Disable warning about wanting an async function
-// tslint:disable-next-line
-gulp.task('generateOptionsSchema', async (): Promise<void> => {
-    optionsSchemaGenerator.GenerateOptionsSchema();
-    return Promise.resolve();
-});
-
-// Disable warning about wanting an async function
-// tslint:disable-next-line
-gulp.task('updatePackageDependencies', async (): Promise<void> => {
-    return packageDependencyUpdater.updatePackageDependencies();
-});
+require('./tasks/debuggerTasks');

omnisharptest/omnisharpUnitTests/common.test.ts renamed to omnisharptest/omnisharpJestTests/common.test.ts

@@ -3,82 +3,79 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import { describe, test, expect } from '@jest/globals';
 import * as path from 'path';
 
 import { isSubfolderOf, safeLength, sum } from '../../src/common';
 
-import { should, expect } from 'chai';
-
-suite('Common', () => {
-    suiteSetup(() => should());
-
-    suite('safeLength', () => {
+describe('Common', () => {
+    describe('safeLength', () => {
         test('return 0 for empty array', () => {
             const array: any[] = [];
             const result = safeLength(array);
-            result.should.equal(0);
+            expect(result).toBe(0);
         });
 
         test('returns 5 for array of 5 elements', () => {
             const array = [1, 2, 3, 4, 5];
             const result = safeLength(array);
-            result.should.equal(5);
+            expect(result).toBe(5);
         });
 
         test('returns 0 for undefined', () => {
             const array = undefined;
             const result = safeLength(array);
-            result.should.equal(0);
+            expect(result).toBe(0);
         });
     });
 
-    suite('sum', () => {
+    describe('sum', () => {
         test('produce total from numbers', () => {
             const array = [1, 2, 3, 4, 5];
             const result = sum(array, (i) => i);
-            result.should.equal(15);
+            expect(result).toBe(15);
         });
 
         test('produce total from lengths of arrays', () => {
             const array = [[1, 2], [3], [], [4, 5, 6]];
             const result = sum(array, (i) => i.length);
-            result.should.equal(6);
+            expect(result).toBe(6);
         });
 
         test('produce total of true values from array of booleans', () => {
             const array = [true, false, false, true, true, true, false, true];
             const result = sum(array, (b) => (b ? 1 : 0));
-            result.should.equal(5);
+            expect(result).toBe(5);
         });
     });
 
-    suite('isSubfolderOf', () => {
+    describe('isSubfolderOf', () => {
         test('same paths', () => {
             const subfolder: string = ['C:', 'temp', 'VS', 'dotnetProject'].join(path.sep);
             const folder: string = ['C:', 'temp', 'VS', 'dotnetProject'].join(path.sep);
 
-            expect(isSubfolderOf(subfolder, folder)).to.be.true;
+            expect(isSubfolderOf(subfolder, folder)).toBe(true);
         });
 
         test('correct subfolder', () => {
-            const subfolder: string = ['C:', 'temp', 'VS'].join(path.sep);
-            const folder: string = ['C:', 'temp', 'VS', 'dotnetProject'].join(path.sep);
+            const folder: string = ['C:', 'temp', 'VS'].join(path.sep);
+            const subfolder: string = ['C:', 'temp', 'VS', 'dotnetProject'].join(path.sep);
 
-            expect(isSubfolderOf(subfolder, folder)).to.be.true;
+            expect(isSubfolderOf(subfolder, folder)).toBe(true);
         });
 
-        test('longer subfolder', () => {
-            const subfolder: string = ['C:', 'temp', 'VS', 'a', 'b', 'c'].join(path.sep);
-            const folder: string = ['C:', 'temp', 'VS'].join(path.sep);
+        test('longer folder', () => {
+            const folder: string = ['C:', 'temp', 'VS', 'a', 'b', 'c'].join(path.sep);
+            const subfolder: string = ['C:', 'temp', 'VS'].join(path.sep);
 
-            expect(isSubfolderOf(subfolder, folder)).to.be.false;
+            expect(isSubfolderOf(subfolder, folder)).toBe(false);
         });
 
         test('Different drive', () => {
             const subfolder: string = ['C:', 'temp', 'VS'].join(path.sep);
             const folder: string = ['E:', 'temp', 'VS'].join(path.sep);
 
-            expect(isSubfolderOf(subfolder, folder)).to.be.false;
+            expect(isSubfolderOf(subfolder, folder)).toBe(false);
         });
     });
 });

omnisharptest/omnisharpJestTests/features/reportIssue.test.ts

@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import reportIssue from '../../../src/shared/reportIssue';
+import { FakeMonoResolver, fakeMonoInfo } from '../../omnisharpUnitTests/fakes/fakeMonoResolver';
+import { FakeDotnetResolver } from '../../omnisharpUnitTests/fakes/fakeDotnetResolver';
+import { DotnetInfo } from '../../../src/shared/utils/dotnetInfo';
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+describe(`${reportIssue.name}`, () => {
+    const vscodeVersion = 'myVersion';
+    const csharpExtVersion = 'csharpExtVersion';
+    const isValidForMono = true;
+    const extension1 = {
+        packageJSON: {
+            name: 'name1',
+            publisher: 'publisher1',
+            version: 'version1',
+            isBuiltin: true,
+        },
+        id: 'id1',
+        extensionPath: 'c:/extensions/abc-x64',
+    } as vscode.Extension<any>;
+
+    const extension2 = {
+        packageJSON: {
+            name: 'name2',
+            publisher: 'publisher2',
+            version: 'version2',
+            isBuiltin: false,
+        },
+        id: 'id2',
+        extensionPath: 'c:/extensions/xyz-x64',
+    } as vscode.Extension<any>;
+
+    const fakeDotnetInfo: DotnetInfo = {
+        FullInfo: 'myDotnetInfo',
+        Version: '1.0.x',
+        RuntimeId: 'win10-x64',
+        Runtimes: {},
+    };
+
+    let fakeMonoResolver: FakeMonoResolver;
+    let fakeDotnetResolver: FakeDotnetResolver;
+    const getDotnetInfo = async () => Promise.resolve(fakeDotnetInfo);
+    let issueBody: string;
+
+    beforeEach(() => {
+        jest.spyOn(vscode.workspace, 'getConfiguration').mockReturnValue({
+            get: jest.fn((_config: string) => {
+                return undefined;
+            }),
+            has: jest.fn(),
+            inspect: jest.fn(),
+            update: jest.fn(),
+        } as vscode.WorkspaceConfiguration);
+
+        jest.spyOn(vscode.commands, 'executeCommand').mockImplementation(async (command: string, ...rest: any[]) => {
+            issueBody = rest[0].issueBody;
+            return {} as any;
+        });
+        jest.replaceProperty(vscode, 'extensions', {
+            all: [extension1, extension2],
+            getExtension: jest.fn(),
+            onDidChange: jest.fn(),
+        } as typeof vscode.extensions);
+
+        fakeMonoResolver = new FakeMonoResolver();
+        fakeDotnetResolver = new FakeDotnetResolver();
+    });
+
+    describe('The body is passed to the vscode clipboard and', () => {
+        test('it contains the vscode version', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(issueBody).toContain(`**VSCode version**: ${vscodeVersion}`);
+        });
+
+        test('it contains the csharp extension version', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(issueBody).toContain(`**C# Extension**: ${csharpExtVersion}`);
+        });
+
+        test('it contains dotnet info', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(issueBody).toContain(fakeDotnetInfo.FullInfo);
+        });
+
+        test('mono information is obtained when it is a valid mono platform', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(fakeMonoResolver.getMonoCalled).toEqual(true);
+        });
+
+        test('mono version is put in the body when it is a valid mono platform', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(fakeMonoResolver.getMonoCalled).toEqual(true);
+            expect(issueBody).toContain(fakeMonoInfo.version);
+        });
+
+        test('mono information is not obtained when it is not a valid mono platform', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, false, fakeDotnetResolver, fakeMonoResolver);
+            expect(fakeMonoResolver.getMonoCalled).toEqual(false);
+        });
+
+        test('The url contains the name, publisher and version for all the extensions that are not builtin', async () => {
+            await reportIssue(csharpExtVersion, getDotnetInfo, isValidForMono, fakeDotnetResolver, fakeMonoResolver);
+            expect(issueBody).toContain(extension2.packageJSON.name);
+            expect(issueBody).toContain(extension2.packageJSON.publisher);
+            expect(issueBody).toContain(extension2.packageJSON.version);
+            expect(issueBody).not.toContain(extension1.packageJSON.name);
+            expect(issueBody).not.toContain(extension1.packageJSON.publisher);
+            expect(issueBody).not.toContain(extension1.packageJSON.version);
+        });
+    });
+});

omnisharptest/omnisharpJestTests/informationMessageObserver.test.ts

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { InformationMessageObserver } from '../../src/observers/informationMessageObserver';
+import { getUnresolvedDependenices, getWorkspaceConfiguration } from '../../test/unitTests/fakes';
+import { Subject, from as observableFrom } from 'rxjs';
+import { timeout } from 'rxjs/operators';
+
+describe('InformationMessageObserver', () => {
+    let doClickOk: () => void;
+    let doClickCancel: () => void;
+    let signalCommandDone: () => void;
+    let commandDone: Promise<void> | undefined;
+    const optionObservable = new Subject<void>();
+    let infoMessage: string | undefined;
+    let invokedCommand: string | undefined;
+    const observer: InformationMessageObserver = new InformationMessageObserver(vscode);
+
+    beforeEach(() => {
+        infoMessage = undefined;
+        invokedCommand = undefined;
+        commandDone = new Promise<void>((resolve) => {
+            signalCommandDone = () => {
+                resolve();
+            };
+        });
+
+        jest.spyOn(vscode.workspace, 'getConfiguration').mockReturnValue(getWorkspaceConfiguration());
+        jest.spyOn(vscode.window, 'showInformationMessage').mockImplementation(
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            //@ts-ignore
+            async <T>(message: string, ...items: T[]) => {
+                infoMessage = message;
+                return new Promise<T | undefined>((resolve) => {
+                    doClickCancel = () => {
+                        resolve(undefined);
+                    };
+
+                    doClickOk = () => {
+                        resolve(items[0]);
+                    };
+
+                    return undefined;
+                });
+            }
+        );
+        jest.spyOn(vscode.commands, 'executeCommand').mockImplementation(async (command: string, ..._: any[]) => {
+            invokedCommand = command;
+            signalCommandDone();
+            return undefined;
+        });
+    });
+
+    [
+        {
+            event: getUnresolvedDependenices('someFile'),
+            expectedCommand: 'dotnet.restore.all',
+        },
+    ].forEach((elem) => {
+        describe(elem.event.constructor.name, () => {
+            describe('Suppress Dotnet Restore Notification is true', () => {
+                beforeEach(() => {
+                    vscode.workspace.getConfiguration().update('csharp.suppressDotnetRestoreNotification', true);
+                    optionObservable.next();
+                });
+
+                test('The information message is not shown', () => {
+                    observer.post(elem.event);
+                    expect(infoMessage).toBeUndefined();
+                });
+            });
+
+            describe('Suppress Dotnet Restore Notification is false', () => {
+                beforeEach(() => {
+                    vscode.workspace.getConfiguration().update('csharp.suppressDotnetRestoreNotification', false);
+                    optionObservable.next();
+                });
+
+                test('The information message is shown', async () => {
+                    observer.post(elem.event);
+                    expect(infoMessage?.length).toBeGreaterThan(0);
+                    doClickOk();
+                    await commandDone;
+                    expect(invokedCommand).toEqual(elem.expectedCommand);
+                });
+
+                test('Given an information message if the user clicks Restore, the command is executed', async () => {
+                    observer.post(elem.event);
+                    doClickOk();
+                    await commandDone;
+                    expect(invokedCommand).toEqual(elem.expectedCommand);
+                });
+
+                test('Given an information message if the user clicks cancel, the command is not executed', async () => {
+                    observer.post(elem.event);
+                    doClickCancel();
+                    await expect(observableFrom(commandDone!).pipe(timeout(1)).toPromise()).rejects.toThrow();
+                    expect(invokedCommand).toBeUndefined();
+                });
+            });
+        });
+    });
+
+    afterEach(() => {
+        commandDone = undefined;
+    });
+});