@zzzen/pyright-internal 1.1.254 → 1.1.255

package/src/common/console.ts

@@ -0,0 +1,201 @@
+/*
+ * console.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Provides an abstraction for console logging and error-reporting
+ * methods.
+ */
+
+import * as debug from './debug';
+
+export enum LogLevel {
+    Error = 'error',
+    Warn = 'warn',
+    Info = 'info',
+    Log = 'log',
+}
+
+export interface ConsoleInterface {
+    error: (message: string) => void;
+    warn: (message: string) => void;
+    info: (message: string) => void;
+    log: (message: string) => void;
+}
+
+// Avoids outputting errors to the console but counts
+// the number of logs and errors, which can be useful
+// for unit tests.
+export class NullConsole implements ConsoleInterface {
+    logCount = 0;
+    infoCount = 0;
+    warnCount = 0;
+    errorCount = 0;
+
+    log(message: string) {
+        this.logCount++;
+    }
+
+    info(message: string) {
+        this.infoCount++;
+    }
+
+    warn(message: string) {
+        this.warnCount++;
+    }
+
+    error(message: string) {
+        this.errorCount++;
+    }
+}
+
+export class StandardConsole implements ConsoleInterface {
+    log(message: string) {
+        console.info(message);
+    }
+
+    info(message: string) {
+        console.info(message);
+    }
+
+    warn(message: string) {
+        console.warn(message);
+    }
+
+    error(message: string) {
+        console.error(message);
+    }
+}
+
+export class StandardConsoleWithLevel extends StandardConsole {
+    constructor(private _maxLevel: LogLevel = LogLevel.Log) {
+        super();
+    }
+
+    get level(): LogLevel {
+        return this._maxLevel;
+    }
+}
+
+export class StderrConsole implements ConsoleInterface {
+    log(message: string) {
+        console.error(message);
+    }
+
+    info(message: string) {
+        console.error(message);
+    }
+
+    warn(message: string) {
+        console.error(message);
+    }
+
+    error(message: string) {
+        console.error(message);
+    }
+}
+
+export class StderrConsoleWithLevel extends StderrConsole {
+    constructor(private _maxLevel: LogLevel = LogLevel.Log) {
+        super();
+    }
+
+    get level(): LogLevel {
+        return this._maxLevel;
+    }
+}
+
+export class ConsoleWithLogLevel implements ConsoleInterface {
+    private _levelMap: Map<string, number> = new Map([
+        [LogLevel.Error, 0],
+        [LogLevel.Warn, 1],
+        [LogLevel.Info, 2],
+        [LogLevel.Log, 3],
+    ]);
+
+    private _maxLevel = 2;
+
+    constructor(private _console: ConsoleInterface, private _name = '') {}
+
+    get level(): LogLevel {
+        switch (this._maxLevel) {
+            case 0:
+                return LogLevel.Error;
+
+            case 1:
+                return LogLevel.Warn;
+
+            case 2:
+                return LogLevel.Info;
+        }
+
+        return LogLevel.Log;
+    }
+
+    set level(value: LogLevel) {
+        let maxLevel = this._levelMap.get(value);
+        if (maxLevel === undefined) {
+            maxLevel = this._levelMap.get(LogLevel.Info)!;
+        }
+
+        this._maxLevel = maxLevel;
+    }
+
+    error(message: string) {
+        this._log(LogLevel.Error, `${this._prefix}${message}`);
+    }
+
+    warn(message: string) {
+        this._log(LogLevel.Warn, `${this._prefix}${message}`);
+    }
+
+    info(message: string) {
+        this._log(LogLevel.Info, `${this._prefix}${message}`);
+    }
+
+    log(message: string) {
+        this._log(LogLevel.Log, `${this._prefix}${message}`);
+    }
+
+    private get _prefix() {
+        return this._name ? `(${this._name}) ` : '';
+    }
+
+    private _log(level: LogLevel, message: string): void {
+        if (this._getNumericalLevel(level) > this._maxLevel) {
+            return;
+        }
+
+        log(this._console, level, message);
+    }
+
+    private _getNumericalLevel(level: LogLevel): number {
+        const numericLevel = this._levelMap.get(level);
+        debug.assert(numericLevel !== undefined, 'Logger: unknown log level.');
+        return numericLevel !== undefined ? numericLevel : 2;
+    }
+}
+
+export function log(console: ConsoleInterface, logType: LogLevel, msg: string) {
+    switch (logType) {
+        case LogLevel.Log:
+            console.log(msg);
+            break;
+
+        case LogLevel.Info:
+            console.info(msg);
+            break;
+
+        case LogLevel.Warn:
+            console.warn(msg);
+            break;
+
+        case LogLevel.Error:
+            console.error(msg);
+            break;
+
+        default:
+            debug.fail(`${logType} is not expected`);
+    }
+}

package/src/common/core.ts

@@ -0,0 +1,152 @@
+/*
+ * core.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Various helpers that don't have a dependency on other code files.
+ */
+
+export const enum Comparison {
+    LessThan = -1,
+    EqualTo = 0,
+    GreaterThan = 1,
+}
+
+/**
+ * Safer version of `Function` which should not be called.
+ * Every function should be assignable to this, but this should not be assignable to every function.
+ */
+export type AnyFunction = (...args: never[]) => void;
+
+/** Do nothing and return false */
+export function returnFalse(): false {
+    return false;
+}
+
+/** Do nothing and return true */
+export function returnTrue(): true {
+    return true;
+}
+
+/** Do nothing and return undefined */
+export function returnUndefined(): undefined {
+    return undefined;
+}
+
+/** Returns its argument. */
+export function identity<T>(x: T) {
+    return x;
+}
+
+/** Returns lower case string */
+export function toLowerCase(x: string) {
+    return x.toLowerCase();
+}
+
+export function equateValues<T>(a: T, b: T) {
+    return a === b;
+}
+
+export type GetCanonicalFileName = (fileName: string) => string;
+
+export function compareComparableValues(a: string | undefined, b: string | undefined): Comparison;
+export function compareComparableValues(a: number | undefined, b: number | undefined): Comparison;
+export function compareComparableValues(a: string | number | undefined, b: string | number | undefined) {
+    return a === b
+        ? Comparison.EqualTo
+        : a === undefined
+        ? Comparison.LessThan
+        : b === undefined
+        ? Comparison.GreaterThan
+        : a < b
+        ? Comparison.LessThan
+        : Comparison.GreaterThan;
+}
+
+/**
+ * Compare two numeric values for their order relative to each other.
+ * To compare strings, use any of the `compareStrings` functions.
+ */
+export function compareValues(a: number | undefined, b: number | undefined): Comparison {
+    return compareComparableValues(a, b);
+}
+
+/**
+ * Tests whether a value is an array.
+ */
+export function isArray(value: any): value is readonly {}[] {
+    return Array.isArray ? Array.isArray(value) : value instanceof Array;
+}
+
+/**
+ * Tests whether a value is string
+ */
+export function isString(text: unknown): text is string {
+    return typeof text === 'string';
+}
+
+export function isNumber(x: unknown): x is number {
+    return typeof x === 'number';
+}
+
+export function isBoolean(x: unknown): x is boolean {
+    return typeof x === 'boolean';
+}
+
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+
+/**
+ * Type of objects whose values are all of the same type.
+ * The `in` and `for-in` operators can *not* be safely used,
+ * since `Object.prototype` may be modified by outside code.
+ */
+export interface MapLike<T> {
+    [index: string]: T;
+}
+
+/**
+ * Indicates whether a map-like contains an own property with the specified key.
+ *
+ * @param map A map-like.
+ * @param key A property key.
+ */
+export function hasProperty(map: MapLike<any>, key: string): boolean {
+    return hasOwnProperty.call(map, key);
+}
+
+/**
+ * Convert the given value to boolean
+ * @param trueOrFalse string value 'true' or 'false'
+ */
+export function toBoolean(trueOrFalse: string): boolean {
+    const normalized = trueOrFalse?.trim().toUpperCase();
+    if (normalized === 'TRUE') {
+        return true;
+    }
+
+    return false;
+}
+
+export function isDebugMode() {
+    const argv = process.execArgv.join();
+    return argv.includes('inspect') || argv.includes('debug');
+}
+
+interface Thenable<T> {
+    then<TResult>(
+        onfulfilled?: (value: T) => TResult | Thenable<TResult>,
+        onrejected?: (reason: any) => TResult | Thenable<TResult>
+    ): Thenable<TResult>;
+    then<TResult>(
+        onfulfilled?: (value: T) => TResult | Thenable<TResult>,
+        onrejected?: (reason: any) => void
+    ): Thenable<TResult>;
+}
+
+export function isThenable<T>(v: any): v is Thenable<T> {
+    return typeof v?.then === 'function';
+}
+
+export function isDefined<T>(element: T | undefined): element is T {
+    return element !== undefined;
+}

package/src/common/crypto.ts

@@ -0,0 +1,60 @@
+/*
+ * crypto.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Platform-independent helper functions for crypto.
+ */
+
+import { fail } from './debug';
+
+let nodeCrypto: typeof import('crypto') | undefined;
+
+try {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    nodeCrypto = require('crypto');
+    if (!nodeCrypto?.randomBytes) {
+        nodeCrypto = undefined;
+    }
+} catch {
+    // Not running in node.
+}
+
+// See lib.dom.d.ts.
+interface Crypto {
+    getRandomValues<
+        T extends
+            | Int8Array
+            | Int16Array
+            | Int32Array
+            | Uint8Array
+            | Uint16Array
+            | Uint32Array
+            | Uint8ClampedArray
+            | Float32Array
+            | Float64Array
+            | DataView
+            | null
+    >(
+        array: T
+    ): T;
+}
+
+declare const crypto: Crypto | undefined;
+
+function arrayToHex(arr: Uint8Array): string {
+    return [...arr].map((x) => x.toString(16).padStart(2, '0')).join('');
+}
+
+export function randomBytesHex(size: number): string {
+    if (nodeCrypto) {
+        return nodeCrypto.randomBytes(size).toString('hex');
+    }
+
+    if (crypto) {
+        const buf = crypto.getRandomValues(new Uint8Array(size));
+        return arrayToHex(buf);
+    }
+
+    fail('crypto library not found');
+}

package/src/common/debug.ts

@@ -0,0 +1,144 @@
+/*
+ * debug.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Helper functions that display user friendly debugging info.
+ */
+
+import { stableSort } from './collectionUtils';
+import { AnyFunction, compareValues, hasProperty, isString } from './core';
+
+export function assert(
+    expression: any,
+    message?: string,
+    verboseDebugInfo?: string | (() => string),
+    stackCrawlMark?: AnyFunction
+): asserts expression {
+    if (!expression) {
+        if (verboseDebugInfo) {
+            message +=
+                '\r\nVerbose Debug Information: ' +
+                (typeof verboseDebugInfo === 'string' ? verboseDebugInfo : verboseDebugInfo());
+        }
+        fail(message ? 'False expression: ' + message : 'False expression.', stackCrawlMark || assert);
+    }
+}
+
+export function fail(message?: string, stackCrawlMark?: AnyFunction): never {
+    // debugger;
+    const e = new Error(message ? `Debug Failure. ${message}` : 'Debug Failure.');
+    if (Error.captureStackTrace) {
+        Error.captureStackTrace(e, stackCrawlMark || fail);
+    }
+    throw e;
+}
+
+export function assertDefined<T>(
+    value: T,
+    message?: string,
+    stackCrawlMark?: AnyFunction
+): asserts value is NonNullable<T> {
+    if (value === undefined || value === null) {
+        fail(message, stackCrawlMark || assertDefined);
+    }
+}
+
+export function assertEachDefined<T>(
+    value: T[],
+    message?: string,
+    stackCrawlMark?: AnyFunction
+): asserts value is NonNullable<T>[] {
+    for (const v of value) {
+        assertDefined(v, message, stackCrawlMark || assertEachDefined);
+    }
+}
+
+export function assertNever(member: never, message = 'Illegal value:', stackCrawlMark?: AnyFunction): never {
+    const detail = JSON.stringify(member);
+    fail(`${message} ${detail}`, stackCrawlMark || assertNever);
+}
+
+export function getFunctionName(func: AnyFunction) {
+    if (typeof func !== 'function') {
+        return '';
+    } else if (hasProperty(func, 'name')) {
+        return (func as any).name;
+    } else {
+        const text = Function.prototype.toString.call(func);
+        const match = /^function\s+([\w$]+)\s*\(/.exec(text);
+        return match ? match[1] : '';
+    }
+}
+
+/**
+ * Formats an enum value as a string for debugging and debug assertions.
+ */
+export function formatEnum(value = 0, enumObject: any, isFlags?: boolean) {
+    const members = getEnumMembers(enumObject);
+    if (value === 0) {
+        return members.length > 0 && members[0][0] === 0 ? members[0][1] : '0';
+    }
+    if (isFlags) {
+        let result = '';
+        let remainingFlags = value;
+        for (const [enumValue, enumName] of members) {
+            if (enumValue > value) {
+                break;
+            }
+            if (enumValue !== 0 && enumValue & value) {
+                result = `${result}${result ? '|' : ''}${enumName}`;
+                remainingFlags &= ~enumValue;
+            }
+        }
+        if (remainingFlags === 0) {
+            return result;
+        }
+    } else {
+        for (const [enumValue, enumName] of members) {
+            if (enumValue === value) {
+                return enumName;
+            }
+        }
+    }
+    return value.toString();
+}
+
+export function getErrorString(error: any): string {
+    return (
+        (error.stack ? error.stack.toString() : undefined) ||
+        (typeof error.message === 'string' ? error.message : undefined) ||
+        JSON.stringify(error)
+    );
+}
+
+export function getSerializableError(error: any): Error | undefined {
+    if (!error) {
+        return undefined;
+    }
+
+    const exception = JSON.stringify(error);
+    if (exception.length > 2) {
+        // Given error object is JSON.stringify serializable. Use it as it is
+        // to preserve properties.
+        return error;
+    }
+
+    // Convert error to JSON.stringify serializable Error shape.
+    const name = error.name ? (isString(error.name) ? error.name : 'noname') : 'noname';
+    const message = error.message ? (isString(error.message) ? error.message : 'nomessage') : 'nomessage';
+    const stack = error.stack ? (isString(error.stack) ? error.stack : undefined) : undefined;
+    return { name, message, stack };
+}
+
+function getEnumMembers(enumObject: any) {
+    const result: [number, string][] = [];
+    for (const name of Object.keys(enumObject)) {
+        const value = enumObject[name];
+        if (typeof value === 'number') {
+            result.push([value, name]);
+        }
+    }
+
+    return stableSort<[number, string]>(result, (x, y) => compareValues(x[0], y[0]));
+}

package/src/common/deferred.ts

@@ -0,0 +1,78 @@
+/*
+ * deferred.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Promise utilities for async operations.
+ */
+
+export interface Deferred<T> {
+    readonly promise: Promise<T>;
+    readonly resolved: boolean;
+    readonly rejected: boolean;
+    readonly completed: boolean;
+    resolve(value?: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+}
+
+class DeferredImpl<T> implements Deferred<T> {
+    private _resolve!: (value: T | PromiseLike<T>) => void;
+    private _reject!: (reason?: any) => void;
+    private _resolved = false;
+    private _rejected = false;
+    private _promise: Promise<T>;
+
+    constructor(private _scope: any = null) {
+        this._promise = new Promise<T>((res, rej) => {
+            this._resolve = res;
+            this._reject = rej;
+        });
+    }
+
+    public resolve(_value?: T | PromiseLike<T>) {
+        // eslint-disable-next-line prefer-rest-params
+        this._resolve.apply(this._scope ? this._scope : this, arguments as any);
+        this._resolved = true;
+    }
+
+    public reject(_reason?: any) {
+        // eslint-disable-next-line prefer-rest-params
+        this._reject.apply(this._scope ? this._scope : this, arguments as any);
+        this._rejected = true;
+    }
+
+    get promise(): Promise<T> {
+        return this._promise;
+    }
+
+    get resolved(): boolean {
+        return this._resolved;
+    }
+
+    get rejected(): boolean {
+        return this._rejected;
+    }
+
+    get completed(): boolean {
+        return this._rejected || this._resolved;
+    }
+}
+
+export function createDeferred<T>(scope: any = null): Deferred<T> {
+    return new DeferredImpl<T>(scope);
+}
+
+export function createDeferredFrom<T>(...promises: Promise<T>[]): Deferred<T> {
+    const deferred = createDeferred<T>();
+    Promise.all<T>(promises)
+        .then(deferred.resolve.bind(deferred) as any)
+        .catch(deferred.reject.bind(deferred) as any);
+
+    return deferred;
+}
+
+export function createDeferredFromPromise<T>(promise: Promise<T>): Deferred<T> {
+    const deferred = createDeferred<T>();
+    promise.then(deferred.resolve.bind(deferred)).catch(deferred.reject.bind(deferred));
+    return deferred;
+}