Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula

extensions/git/src/util.ts

@@ -6,7 +6,8 @@
 'use strict';
 
 import { Event } from 'vscode';
-import { dirname } from 'path';
+import { dirname, sep } from 'path';
+import { Readable } from 'stream';
 import * as fs from 'fs';
 import * as byline from 'byline';
 
@@ -86,7 +87,7 @@ export function once(fn: (...args: any[]) => any): (...args: any[]) => any {
 
 export function assign<T>(destination: T, ...sources: any[]): T {
 	for (const source of sources) {
-		Object.keys(source).forEach(key => destination[key] = source[key]);
+		Object.keys(source).forEach(key => (destination as any)[key] = source[key]);
 	}
 
 	return destination;
@@ -115,12 +116,12 @@ export function groupBy<T>(arr: T[], fn: (el: T) => string): { [key: string]: T[
 	}, Object.create(null));
 }
 
-export function denodeify<R>(fn: Function): (...args) => Promise<R> {
-	return (...args) => new Promise<R>((c, e) => fn(...args, (err, r) => err ? e(err) : c(r)));
+export function denodeify<R>(fn: Function): (...args: any[]) => Promise<R> {
+	return (...args) => new Promise<R>((c, e) => fn(...args, (err: any, r: any) => err ? e(err) : c(r)));
 }
 
-export function nfcall<R>(fn: Function, ...args): Promise<R> {
-	return new Promise<R>((c, e) => fn(...args, (err, r) => err ? e(err) : c(r)));
+export function nfcall<R>(fn: Function, ...args: any[]): Promise<R> {
+	return new Promise<R>((c, e) => fn(...args, (err: any, r: any) => err ? e(err) : c(r)));
 }
 
 export async function mkdirp(path: string, mode?: number): Promise<boolean> {
@@ -205,4 +206,83 @@ export async function grep(filename: string, pattern: RegExp): Promise<boolean>
 		stream.on('error', e);
 		stream.on('end', () => c(false));
 	});
-}
+}
+
+export function readBytes(stream: Readable, bytes: number): Promise<Buffer> {
+	return new Promise<Buffer>((complete, error) => {
+		let done = false;
+		let buffer = new Buffer(bytes);
+		let bytesRead = 0;
+
+		stream.on('data', (data: Buffer) => {
+			let bytesToRead = Math.min(bytes - bytesRead, data.length);
+			data.copy(buffer, bytesRead, 0, bytesToRead);
+			bytesRead += bytesToRead;
+
+			if (bytesRead === bytes) {
+				(stream as any).destroy(); // Will trigger the close event eventually
+			}
+		});
+
+		stream.on('error', (e: Error) => {
+			if (!done) {
+				done = true;
+				error(e);
+			}
+		});
+
+		stream.on('close', () => {
+			if (!done) {
+				done = true;
+				complete(buffer.slice(0, bytesRead));
+			}
+		});
+	});
+}
+
+export enum Encoding {
+	UTF8 = 'utf8',
+	UTF16be = 'utf16be',
+	UTF16le = 'utf16le'
+}
+
+export function detectUnicodeEncoding(buffer: Buffer): Encoding | null {
+	if (buffer.length < 2) {
+		return null;
+	}
+
+	const b0 = buffer.readUInt8(0);
+	const b1 = buffer.readUInt8(1);
+
+	if (b0 === 0xFE && b1 === 0xFF) {
+		return Encoding.UTF16be;
+	}
+
+	if (b0 === 0xFF && b1 === 0xFE) {
+		return Encoding.UTF16le;
+	}
+
+	if (buffer.length < 3) {
+		return null;
+	}
+
+	const b2 = buffer.readUInt8(2);
+
+	if (b0 === 0xEF && b1 === 0xBB && b2 === 0xBF) {
+		return Encoding.UTF8;
+	}
+
+	return null;
+}
+
+export function isDescendant(parent: string, descendant: string): boolean {
+	if (parent === descendant) {
+		return true;
+	}
+
+	if (parent.charAt(parent.length - 1) !== sep) {
+		parent += sep;
+	}
+
+	return descendant.startsWith(parent);
+}