Merge from vscode 52dcb723a39ae75bee1bd56b3312d7fcdc87aeed (#6719)

src/vs/base/node/encoding.ts

@@ -14,6 +14,12 @@ export const UTF8_with_bom = 'utf8bom';
 export const UTF16be = 'utf16be';
 export const UTF16le = 'utf16le';
 
+export type UTF_ENCODING = typeof UTF8 | typeof UTF8_with_bom | typeof UTF16be | typeof UTF16le;
+
+export function isUTFEncoding(encoding: string): encoding is UTF_ENCODING {
+	return [UTF8, UTF8_with_bom, UTF16be, UTF16le].some(utfEncoding => utfEncoding === encoding);
+}
+
 export const UTF16be_BOM = [0xFE, 0xFF];
 export const UTF16le_BOM = [0xFF, 0xFE];
 export const UTF8_BOM = [0xEF, 0xBB, 0xBF];
@@ -41,8 +47,8 @@ export function toDecodeStream(readable: Readable, options: IDecodeStreamOptions
 
 	return new Promise<IDecodeStreamResult>((resolve, reject) => {
 		const writer = new class extends Writable {
-			private decodeStream: NodeJS.ReadWriteStream;
-			private decodeStreamPromise: Promise<void>;
+			private decodeStream: NodeJS.ReadWriteStream | undefined;
+			private decodeStreamPromise: Promise<void> | undefined;
 
 			private bufferedChunks: Buffer[] = [];
 			private bytesBuffered = 0;
@@ -116,7 +122,7 @@ export function toDecodeStream(readable: Readable, options: IDecodeStreamOptions
 				// detection. thus, wrap up starting the stream even
 				// without all the data to get things going
 				else {
-					this._startDecodeStream(() => this.decodeStream.end(callback));
+					this._startDecodeStream(() => this.decodeStream!.end(callback));
 				}
 			}
 		};

src/vs/base/node/pfs.ts

@@ -138,20 +138,6 @@ export async function readdir(path: string): Promise<string[]> {
 	return handleDirectoryChildren(await promisify(fs.readdir)(path));
 }
 
-export async function readdirWithFileTypes(path: string): Promise<fs.Dirent[]> {
-	const children = await promisify(fs.readdir)(path, { withFileTypes: true });
-
-	// Mac: uses NFD unicode form on disk, but we want NFC
-	// See also https://github.com/nodejs/node/issues/2165
-	if (platform.isMacintosh) {
-		for (const child of children) {
-			child.name = normalizeNFC(child.name);
-		}
-	}
-
-	return children;
-}
-
 export function readdirSync(path: string): string[] {
 	return handleDirectoryChildren(fs.readdirSync(path));
 }

src/vs/base/node/stream.ts

@@ -4,6 +4,10 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as fs from 'fs';
+import { VSBufferReadableStream, VSBufferReadable, VSBuffer } from 'vs/base/common/buffer';
+import { Readable } from 'stream';
+import { isUndefinedOrNull } from 'vs/base/common/types';
+import { UTF8, UTF8_with_bom, UTF8_BOM, UTF16be, UTF16le_BOM, UTF16be_BOM, UTF16le, UTF_ENCODING } from 'vs/base/node/encoding';
 
 /**
  * Reads a file until a matching string is found.
@@ -66,4 +70,107 @@ export function readToMatchingString(file: string, matchingString: string, chunk
 			readChunk();
 		})
 	);
-}
+}
+
+export function streamToNodeReadable(stream: VSBufferReadableStream): Readable {
+	return new class extends Readable {
+		private listening = false;
+
+		_read(size?: number): void {
+			if (!this.listening) {
+				this.listening = true;
+
+				// Data
+				stream.on('data', data => {
+					try {
+						if (!this.push(data.buffer)) {
+							stream.pause(); // pause the stream if we should not push anymore
+						}
+					} catch (error) {
+						this.emit(error);
+					}
+				});
+
+				// End
+				stream.on('end', () => {
+					try {
+						this.push(null); // signal EOS
+					} catch (error) {
+						this.emit(error);
+					}
+				});
+
+				// Error
+				stream.on('error', error => this.emit('error', error));
+			}
+
+			// ensure the stream is flowing
+			stream.resume();
+		}
+
+		_destroy(error: Error | null, callback: (error: Error | null) => void): void {
+			stream.destroy();
+
+			callback(null);
+		}
+	};
+}
+
+export function nodeReadableToString(stream: NodeJS.ReadableStream): Promise<string> {
+	return new Promise((resolve, reject) => {
+		let result = '';
+
+		stream.on('data', chunk => result += chunk);
+		stream.on('error', reject);
+		stream.on('end', () => resolve(result));
+	});
+}
+
+export function nodeStreamToVSBufferReadable(stream: NodeJS.ReadWriteStream, addBOM?: { encoding: UTF_ENCODING }): VSBufferReadable {
+	let bytesRead = 0;
+	let done = false;
+
+	return {
+		read(): VSBuffer | null {
+			if (done) {
+				return null;
+			}
+
+			const res = stream.read();
+			if (isUndefinedOrNull(res)) {
+				done = true;
+
+				// If we are instructed to add a BOM but we detect that no
+				// bytes have been read, we must ensure to return the BOM
+				// ourselves so that we comply with the contract.
+				if (bytesRead === 0 && addBOM) {
+					switch (addBOM.encoding) {
+						case UTF8:
+						case UTF8_with_bom:
+							return VSBuffer.wrap(Buffer.from(UTF8_BOM));
+						case UTF16be:
+							return VSBuffer.wrap(Buffer.from(UTF16be_BOM));
+						case UTF16le:
+							return VSBuffer.wrap(Buffer.from(UTF16le_BOM));
+					}
+				}
+
+				return null;
+			}
+
+			// Handle String
+			if (typeof res === 'string') {
+				bytesRead += res.length;
+
+				return VSBuffer.fromString(res);
+			}
+
+			// Handle Buffer
+			else {
+				bytesRead += res.byteLength;
+
+				return VSBuffer.wrap(res);
+			}
+		}
+	};
+}