Merge branch 'main' into aamunger/fileBackedIW

Author: amunger

extensions/typescript-language-features/src/extension.browser.ts

@@ -109,18 +109,16 @@ async function preload(logger: Logger): Promise<void> {
 
 	const workspaceUri = vscode.workspace.workspaceFolders?.[0].uri;
 	if (!workspaceUri || workspaceUri.scheme !== 'vscode-vfs' || workspaceUri.authority !== 'github') {
-		return undefined;
+		logger.info(`Skipped loading workspace contents for repository ${workspaceUri?.toString()}`);
+		return;
 	}
 
 	try {
 		const remoteHubApi = await RemoteRepositories.getApi();
-		if (remoteHubApi.loadWorkspaceContents !== undefined) {
-			if (await remoteHubApi.loadWorkspaceContents(workspaceUri)) {
-				logger.info(`Successfully loaded workspace content for repository ${workspaceUri.toString()}`);
-			} else {
-				logger.info(`Failed to load workspace content for repository ${workspaceUri.toString()}`);
-			}
-
+		if (await remoteHubApi.loadWorkspaceContents?.(workspaceUri)) {
+			logger.info(`Successfully loaded workspace content for repository ${workspaceUri.toString()}`);
+		} else {
+			logger.info(`Failed to load workspace content for repository ${workspaceUri.toString()}`);
 		}
 	} catch (error) {
 		logger.info(`Loading workspace content for repository ${workspaceUri.toString()} failed: ${error instanceof Error ? error.toString() : 'Unknown reason'}`);

src/vs/code/electron-main/app.ts

@@ -1251,6 +1251,11 @@ export class CodeApplication extends Disposable {
 
 		// Crash reporter
 		this.updateCrashReporterEnablement();
+
+		if (app.runningUnderARM64Translation) {
+			this.windowsMainService?.sendToFocused('vscode:showTranslatedBuildWarning');
+		}
+
 	}
 
 	private async installMutex(): Promise<void> {

src/vs/editor/browser/widget/diffEditorWidget.ts

@@ -143,6 +143,7 @@ class VisualEditorState {
 			for (let i = 0, length = newDecorations.zones.length; i < length; i++) {
 				const viewZone = <editorBrowser.IViewZone>newDecorations.zones[i];
 				viewZone.suppressMouseDown = true;
+				viewZone.showInHiddenAreas = true;
 				const zoneId = viewChangeAccessor.addZone(viewZone);
 				this._zones.push(zoneId);
 				this._zonesMap[String(zoneId)] = true;

src/vs/editor/browser/widget/diffEditorWidget2/lineAlignment.ts

@@ -213,6 +213,7 @@ export class ViewZoneManager extends Disposable {
 									afterLineNumber: a.originalRange.startLineNumber + i,
 									domNode: createFakeLinesDiv(),
 									heightInPx: (count - 1) * modLineHeight,
+									showInHiddenAreas: true,
 								});
 							}
 						}
@@ -224,6 +225,7 @@ export class ViewZoneManager extends Disposable {
 							minWidthInPx: result.minWidthInPx,
 							marginDomNode,
 							setZoneId(id) { zoneId = id; },
+							showInHiddenAreas: true,
 						});
 					}
 
@@ -290,12 +292,14 @@ export class ViewZoneManager extends Disposable {
 						afterLineNumber: a.originalRange.endLineNumberExclusive - 1,
 						domNode: createFakeLinesDiv(),
 						heightInPx: delta,
+						showInHiddenAreas: true,
 					});
 				} else {
 					modViewZones.push({
 						afterLineNumber: a.modifiedRange.endLineNumberExclusive - 1,
 						domNode: createFakeLinesDiv(),
 						heightInPx: -delta,
+						showInHiddenAreas: true,
 					});
 				}
 			}

src/vs/editor/common/config/editorOptions.ts

@@ -4629,6 +4629,7 @@ class EditorSuggest extends BaseEditorOption<EditorOption.suggest, ISuggestOptio
 
 export interface ISmartSelectOptions {
 	selectLeadingAndTrailingWhitespace?: boolean;
+	selectSubwords?: boolean;
 }
 
 /**
@@ -4642,13 +4643,19 @@ class SmartSelect extends BaseEditorOption<EditorOption.smartSelect, ISmartSelec
 		super(
 			EditorOption.smartSelect, 'smartSelect',
 			{
-				selectLeadingAndTrailingWhitespace: true
+				selectLeadingAndTrailingWhitespace: true,
+				selectSubwords: true,
 			},
 			{
 				'editor.smartSelect.selectLeadingAndTrailingWhitespace': {
 					description: nls.localize('selectLeadingAndTrailingWhitespace', "Whether leading and trailing whitespace should always be selected."),
 					default: true,
 					type: 'boolean'
+				},
+				'editor.smartSelect.selectSubwords': {
+					description: nls.localize('selectSubwords', "Whether subwords (like 'foo' in 'fooBar' or 'foo_bar') should be selected."),
+					default: true,
+					type: 'boolean'
 				}
 			}
 		);
@@ -4659,7 +4666,8 @@ class SmartSelect extends BaseEditorOption<EditorOption.smartSelect, ISmartSelec
 			return this.defaultValue;
 		}
 		return {
-			selectLeadingAndTrailingWhitespace: boolean((input as ISmartSelectOptions).selectLeadingAndTrailingWhitespace, this.defaultValue.selectLeadingAndTrailingWhitespace)
+			selectLeadingAndTrailingWhitespace: boolean((input as ISmartSelectOptions).selectLeadingAndTrailingWhitespace, this.defaultValue.selectLeadingAndTrailingWhitespace),
+			selectSubwords: boolean((input as ISmartSelectOptions).selectSubwords, this.defaultValue.selectSubwords),
 		};
 	}
 }

src/vs/editor/common/diff/algorithms/myersDiffAlgorithm.ts

@@ -39,15 +39,23 @@ export class MyersDiffAlgorithm implements IDiffAlgorithm {
 
 		loop: while (true) {
 			d++;
-			for (k = -d; k <= d; k += 2) {
-				if (!timeout.isValid()) {
-					return DiffAlgorithmResult.trivialTimedOut(seq1, seq2);
-				}
-
-				const maxXofDLineTop = k === d ? -1 : V.get(k + 1); // We take a vertical non-diagonal
-				const maxXofDLineLeft = k === -d ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x)
+			if (!timeout.isValid()) {
+				return DiffAlgorithmResult.trivialTimedOut(seq1, seq2);
+			}
+			// The paper has `for (k = -d; k <= d; k += 2)`, but we can ignore diagonals that cannot influence the result.
+			const lowerBound = -Math.min(d, seq2.length + (d % 2));
+			const upperBound = Math.min(d, seq1.length + (d % 2));
+			for (k = lowerBound; k <= upperBound; k += 2) {
+				// We can use the X values of (d-1)-lines to compute X value of the longest d-lines.
+				const maxXofDLineTop = k === upperBound ? -1 : V.get(k + 1); // We take a vertical non-diagonal (add a symbol in seq1)
+				const maxXofDLineLeft = k === lowerBound ? -1 : V.get(k - 1) + 1; // We take a horizontal non-diagonal (+1 x) (delete a symbol in seq1)
 				const x = Math.min(Math.max(maxXofDLineTop, maxXofDLineLeft), seq1.length);
 				const y = x - k;
+				if (x > seq1.length || y > seq2.length) {
+					// This diagonal is irrelevant for the result.
+					// TODO: Don't pay the cost for this in the next iteration.
+					continue;
+				}
 				const newMaxX = getXAfterSnake(x, y);
 				V.set(k, newMaxX);
 				const lastPath = x === maxXofDLineTop ? paths.get(k + 1) : paths.get(k - 1);

src/vs/editor/contrib/dropOrPasteInto/browser/copyPasteController.ts

@@ -114,7 +114,18 @@ export class CopyPasteController extends Disposable implements IEditorContributi
 	}
 
 	private handleCopy(e: ClipboardEvent) {
-		if (!e.clipboardData || !this._editor.hasTextFocus() || !this.isPasteAsEnabled()) {
+		if (!this._editor.hasTextFocus()) {
+			return;
+		}
+
+		if (platform.isWeb) {
+			// Explicitly clear the web resources clipboard.
+			// This is needed because on web, the browser clipboard is faked out using an in-memory store.
+			// This means the resources clipboard is not properly updated when copying from the editor.
+			this._clipboardService.writeResources([]);
+		}
+
+		if (!e.clipboardData || !this.isPasteAsEnabled()) {
 			return;
 		}
 

src/vs/editor/contrib/smartSelect/browser/smartSelect.ts

@@ -208,12 +208,13 @@ registerEditorAction(ShrinkSelectionAction);
 
 export interface SelectionRangesOptions {
 	selectLeadingAndTrailingWhitespace: boolean;
+	selectSubwords: boolean;
 }
 
 export async function provideSelectionRanges(registry: LanguageFeatureRegistry<languages.SelectionRangeProvider>, model: ITextModel, positions: Position[], options: SelectionRangesOptions, token: CancellationToken): Promise<Range[][]> {
 
 	const providers = registry.all(model)
-		.concat(new WordSelectionRangeProvider()); // ALWAYS have word based selection range
+		.concat(new WordSelectionRangeProvider(options.selectSubwords)); // ALWAYS have word based selection range
 
 	if (providers.length === 1) {
 		// add word selection and bracket selection when no provider exists
@@ -313,7 +314,7 @@ CommandsRegistry.registerCommand('_executeSelectionRangeProvider', async functio
 	const reference = await accessor.get(ITextModelService).createModelReference(resource);
 
 	try {
-		return provideSelectionRanges(registry, reference.object.textEditorModel, positions, { selectLeadingAndTrailingWhitespace: true }, CancellationToken.None);
+		return provideSelectionRanges(registry, reference.object.textEditorModel, positions, { selectLeadingAndTrailingWhitespace: true, selectSubwords: true }, CancellationToken.None);
 	} finally {
 		reference.dispose();
 	}

src/vs/editor/contrib/smartSelect/browser/wordSelections.ts

@@ -12,12 +12,16 @@ import { SelectionRange, SelectionRangeProvider } from 'vs/editor/common/languag
 
 export class WordSelectionRangeProvider implements SelectionRangeProvider {
 
+	constructor(private readonly selectSubwords = true) { }
+
 	provideSelectionRanges(model: ITextModel, positions: Position[]): SelectionRange[][] {
 		const result: SelectionRange[][] = [];
 		for (const position of positions) {
 			const bucket: SelectionRange[] = [];
 			result.push(bucket);
-			this._addInWordRanges(bucket, model, position);
+			if (this.selectSubwords) {
+				this._addInWordRanges(bucket, model, position);
+			}
 			this._addWordRanges(bucket, model, position);
 			this._addWhitespaceLine(bucket, model, position);
 			bucket.push({ range: model.getFullModelRange() });

src/vs/editor/contrib/smartSelect/test/browser/smartSelect.test.ts

@@ -67,7 +67,7 @@ suite('SmartSelect', () => {
 	async function assertGetRangesToPosition(text: string[], lineNumber: number, column: number, ranges: Range[], selectLeadingAndTrailingWhitespace = true): Promise<void> {
 		const uri = URI.file('test.js');
 		const model = modelService.createModel(text.join('\n'), new StaticLanguageSelector(languageId), uri);
-		const [actual] = await provideSelectionRanges(providers, model, [new Position(lineNumber, column)], { selectLeadingAndTrailingWhitespace }, CancellationToken.None);
+		const [actual] = await provideSelectionRanges(providers, model, [new Position(lineNumber, column)], { selectLeadingAndTrailingWhitespace, selectSubwords: true }, CancellationToken.None);
 		const actualStr = actual!.map(r => new Range(r.startLineNumber, r.startColumn, r.endLineNumber, r.endColumn).toString());
 		const desiredStr = ranges.reverse().map(r => String(r));
 
@@ -294,6 +294,24 @@ suite('SmartSelect', () => {
 		);
 	});
 
+	test('in-word ranges with selectSubwords=false', async () => {
+
+		await assertRanges(new WordSelectionRangeProvider(false), 'f|ooBar',
+			new Range(1, 1, 1, 7),
+			new Range(1, 1, 1, 7),
+		);
+
+		await assertRanges(new WordSelectionRangeProvider(false), 'f|oo_Ba',
+			new Range(1, 1, 1, 7),
+			new Range(1, 1, 1, 7),
+		);
+
+		await assertRanges(new WordSelectionRangeProvider(false), 'f|oo-Ba',
+			new Range(1, 1, 1, 7),
+			new Range(1, 1, 1, 7),
+		);
+	});
+
 	test('Default selection should select current word/hump first in camelCase #67493', async function () {
 
 		await assertRanges(new WordSelectionRangeProvider(), 'Abs|tractSmartSelect',