[pull] main from microsoft:main

.vscode/tasks.json

@@ -73,10 +73,11 @@
 				"owner": "typescript",
 				"applyTo": "closedDocuments",
 				"fileLocation": [
-					"absolute"
+					"relative",
+					"${workspaceFolder}"
 				],
 				"pattern": {
-					"regexp": "Error: ([^(]+)\\((\\d+|\\d+,\\d+|\\d+,\\d+,\\d+,\\d+)\\): (.*)$",
+					"regexp": "\\] ([^(]+)\\((\\d+,\\d+)\\): (.*)$",
 					"file": 1,
 					"location": 2,
 					"message": 3

build/gulpfile.extensions.ts

@@ -8,6 +8,7 @@ import { EventEmitter } from 'events';
 EventEmitter.defaultMaxListeners = 100;
 
 import es from 'event-stream';
+import fancyLog from 'fancy-log';
 import glob from 'glob';
 import gulp from 'gulp';
 import filter from 'gulp-filter';
@@ -27,6 +28,25 @@ import watcher from './lib/watch/index.ts';
 const root = path.dirname(import.meta.dirname);
 const commit = getVersion(root);
 
+// Tracks active extension compilations to emit aggregate
+// "Starting compilation" / "Finished compilation" messages
+// that the problem matcher in tasks.json relies on.
+let activeExtensionCompilations = 0;
+
+function onExtensionCompilationStart(): void {
+	if (activeExtensionCompilations === 0) {
+		fancyLog('Starting compilation');
+	}
+	activeExtensionCompilations++;
+}
+
+function onExtensionCompilationEnd(): void {
+	activeExtensionCompilations--;
+	if (activeExtensionCompilations === 0) {
+		fancyLog('Finished compilation');
+	}
+}
+
 // To save 250ms for each gulp startup, we are caching the result here
 // const compilations = glob.sync('**/tsconfig.json', {
 // 	cwd: extensionsPath,
@@ -175,7 +195,25 @@ const tasks = compilations.map(function (tsconfigFile) {
 		const nonts = gulp.src(src, srcOpts).pipe(filter(['**', '!**/*.ts'], { dot: true }));
 		const watchInput = watcher(src, { ...srcOpts, ...{ readDelay: 200 } });
 		const watchNonTs = watchInput.pipe(filter(['**', '!**/*.ts'], { dot: true })).pipe(gulp.dest(out));
-		const tsgoStream = watchInput.pipe(util.debounce(() => createTsgoStream(absolutePath, { taskName: 'extensions' }, () => rewriteTsgoSourceMappingUrlsIfNeeded(false, out, baseUrl)), 200));
+		const tsgoStream = watchInput.pipe(util.debounce(() => {
+			onExtensionCompilationStart();
+			const stream = createTsgoStream(absolutePath, { taskName: 'extensions' }, () => rewriteTsgoSourceMappingUrlsIfNeeded(false, out, baseUrl));
+			// Wrap in a result stream that always emits 'end' (even on
+			// error) so the debounce resets to idle and can process future
+			// file changes. Errors from tsgo (e.g. type errors causing a
+			// non-zero exit code) are already reported by spawnTsgo's
+			// runReporter, so swallowing the stream error is safe.
+			const result = es.through();
+			stream.on('end', () => {
+				onExtensionCompilationEnd();
+				result.emit('end');
+			});
+			stream.on('error', () => {
+				onExtensionCompilationEnd();
+				result.emit('end');
+			});
+			return result;
+		}, 200));
 		const watchStream = es.merge(nonts.pipe(gulp.dest(out)), watchNonTs, tsgoStream);
 
 		return watchStream;

build/lib/extensions.ts

@@ -441,7 +441,7 @@ interface IExtensionManifest {
 /**
  * Loosely based on `getExtensionKind` from `src/vs/workbench/services/extensions/common/extensionManifestPropertiesService.ts`
  */
-function isWebExtension(manifest: IExtensionManifest): boolean {
+export function isWebExtension(manifest: IExtensionManifest): boolean {
 	if (Boolean(manifest.browser)) {
 		return true;
 	}
@@ -578,11 +578,11 @@ export function packageMarketplaceExtensionsStream(forWeb: boolean): Stream {
 }
 
 export interface IScannedBuiltinExtension {
-	extensionPath: string;
-	packageJSON: any;
-	packageNLS?: any;
-	readmePath?: string;
-	changelogPath?: string;
+	readonly extensionPath: string;
+	readonly packageJSON: unknown;
+	readonly packageNLS: unknown | undefined;
+	readonly readmePath: string | undefined;
+	readonly changelogPath: string | undefined;
 }
 
 export function scanBuiltinExtensions(extensionsRoot: string, exclude: string[] = []): IScannedBuiltinExtension[] {

build/lib/tsgo.ts

@@ -12,13 +12,17 @@ import * as path from 'path';
 const root = path.dirname(path.dirname(import.meta.dirname));
 const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
 const ansiRegex = /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g;
+const timestampRegex = /^\[\d{2}:\d{2}:\d{2}\]\s*/;
 
 export function spawnTsgo(projectPath: string, config: { taskName: string; noEmit?: boolean }, onComplete?: () => Promise<void> | void): Promise<void> {
-	function runReporter(stdError: string) {
-		const matches = (stdError || '').match(/error \w+: (.+)?/g);
-		fancyLog(`Finished ${ansiColors.green(config.taskName)} ${projectPath} with ${matches ? matches.length : 0} errors.`);
-		for (const match of matches || []) {
-			fancyLog.error(match);
+	function runReporter(output: string) {
+		const lines = (output || '').split('\n');
+		const errorLines = lines.filter(line => /error \w+:/.test(line));
+		if (errorLines.length > 0) {
+			fancyLog(`Finished ${ansiColors.green(config.taskName)} ${projectPath} with ${errorLines.length} errors.`);
+			for (const line of errorLines) {
+				fancyLog(line);
+			}
 		}
 	}
 
@@ -34,21 +38,28 @@ export function spawnTsgo(projectPath: string, config: { taskName: string; noEmi
 		shell: true
 	});
 
-	const handleData = (data: Buffer) => {
-		const lines = data.toString()
-			.split(/\r?\n/)
-			.map(line => line.replace(ansiRegex, '').trim())
-			.filter(line => line.length > 0)
-			.filter(line => !/Starting compilation|File change detected|Compilation complete/i.test(line));
-
-		runReporter(lines.join('\n'));
-	};
+	let stdoutData = '';
+	let stderrData = '';
 
-	child.stdout?.on('data', handleData);
-	child.stderr?.on('data', handleData);
+	child.stdout?.on('data', (data: Buffer) => {
+		stdoutData += data.toString();
+	});
+	child.stderr?.on('data', (data: Buffer) => {
+		stderrData += data.toString();
+	});
 
 	return new Promise<void>((resolve, reject) => {
 		child.on('exit', code => {
+			const allOutput = stdoutData + '\n' + stderrData;
+			const lines = allOutput
+				.split(/\r?\n/)
+				.map(line => line.replace(ansiRegex, '').trim())
+				.map(line => line.replace(timestampRegex, ''))
+				.filter(line => line.length > 0)
+				.filter(line => !/Starting compilation|File change detected|Compilation complete/i.test(line));
+
+			runReporter(lines.join('\n'));
+
 			if (code === 0) {
 				Promise.resolve(onComplete?.()).then(() => resolve(), reject);
 			} else {

build/next/index.ts

@@ -15,6 +15,7 @@ import { getVersion } from '../lib/getVersion.ts';
 import product from '../../product.json' with { type: 'json' };
 import packageJson from '../../package.json' with { type: 'json' };
 import { useEsbuildTranspile } from '../buildConfig.ts';
+import { isWebExtension, type IScannedBuiltinExtension } from '../lib/extensions.ts';
 
 const globAsync = promisify(glob);
 
@@ -378,33 +379,43 @@ async function cleanDir(dir: string): Promise<void> {
  * Scan for built-in extensions in the given directory.
  * Returns an array of extension entries for the builtinExtensionsScannerService.
  */
-function scanBuiltinExtensions(extensionsRoot: string): Array<{ extensionPath: string; packageJSON: unknown }> {
-	const result: Array<{ extensionPath: string; packageJSON: unknown }> = [];
+function scanBuiltinExtensions(extensionsRoot: string): Array<IScannedBuiltinExtension> {
+	const scannedExtensions: Array<IScannedBuiltinExtension> = [];
 	const extensionsPath = path.join(REPO_ROOT, extensionsRoot);
 
 	if (!fs.existsSync(extensionsPath)) {
-		return result;
+		return scannedExtensions;
 	}
 
-	for (const entry of fs.readdirSync(extensionsPath, { withFileTypes: true })) {
-		if (!entry.isDirectory()) {
+	for (const extensionFolder of fs.readdirSync(extensionsPath)) {
+		const packageJSONPath = path.join(extensionsPath, extensionFolder, 'package.json');
+		if (!fs.existsSync(packageJSONPath)) {
 			continue;
 		}
-		const packageJsonPath = path.join(extensionsPath, entry.name, 'package.json');
-		if (fs.existsSync(packageJsonPath)) {
-			try {
-				const packageJSON = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-				result.push({
-					extensionPath: entry.name,
-					packageJSON
-				});
-			} catch (e) {
-				// Skip invalid extensions
+		try {
+			const packageJSON = JSON.parse(fs.readFileSync(packageJSONPath, 'utf8'));
+			if (!isWebExtension(packageJSON)) {
+				continue;
 			}
+			const children = fs.readdirSync(path.join(extensionsPath, extensionFolder));
+			const packageNLSPath = children.filter(child => child === 'package.nls.json')[0];
+			const packageNLS = packageNLSPath ? JSON.parse(fs.readFileSync(path.join(extensionsPath, extensionFolder, packageNLSPath), 'utf8')) : undefined;
+			const readme = children.filter(child => /^readme(\.txt|\.md|)$/i.test(child))[0];
+			const changelog = children.filter(child => /^changelog(\.txt|\.md|)$/i.test(child))[0];
+
+			scannedExtensions.push({
+				extensionPath: extensionFolder,
+				packageJSON,
+				packageNLS,
+				readmePath: readme ? path.join(extensionFolder, readme) : undefined,
+				changelogPath: changelog ? path.join(extensionFolder, changelog) : undefined,
+			});
+		} catch (e) {
+			// Skip invalid extensions
 		}
 	}
 
-	return result;
+	return scannedExtensions;
 }
 
 /**