@zzzen/pyright-internal 1.1.254

package/dist/pyright.js

@@ -0,0 +1,645 @@
+"use strict";
+/*
+ * pyright.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Command-line entry point for pyright type checker.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = void 0;
+// Add the start timer at the very top of the file, before we import other modules.
+/* eslint-disable */
+const timing_1 = require("./common/timing");
+/* eslint-enable */
+const chalk_1 = __importDefault(require("chalk"));
+const command_line_args_1 = __importDefault(require("command-line-args"));
+const packageTypeVerifier_1 = require("./analyzer/packageTypeVerifier");
+const service_1 = require("./analyzer/service");
+const commandLineOptions_1 = require("./common/commandLineOptions");
+const console_1 = require("./common/console");
+const pathUtils_1 = require("./common/pathUtils");
+const realFileSystem_1 = require("./common/realFileSystem");
+const textRange_1 = require("./common/textRange");
+const pythonVersion_1 = require("./common/pythonVersion");
+const pyrightFileSystem_1 = require("./pyrightFileSystem");
+const deferred_1 = require("./common/deferred");
+const fullAccessHost_1 = require("./common/fullAccessHost");
+const chokidarFileWatcherProvider_1 = require("./common/chokidarFileWatcherProvider");
+const toolName = 'pyright';
+var ExitStatus;
+(function (ExitStatus) {
+    ExitStatus[ExitStatus["NoErrors"] = 0] = "NoErrors";
+    ExitStatus[ExitStatus["ErrorsReported"] = 1] = "ErrorsReported";
+    ExitStatus[ExitStatus["FatalError"] = 2] = "FatalError";
+    ExitStatus[ExitStatus["ConfigFileParseError"] = 3] = "ConfigFileParseError";
+    ExitStatus[ExitStatus["ParameterError"] = 4] = "ParameterError";
+})(ExitStatus || (ExitStatus = {}));
+const cancellationNone = Object.freeze({
+    isCancellationRequested: false,
+    onCancellationRequested: function () {
+        return {
+            dispose() {
+                /* empty */
+            },
+        };
+    },
+});
+async function processArgs() {
+    const optionDefinitions = [
+        { name: 'createstub', type: String },
+        { name: 'dependencies', type: Boolean },
+        { name: 'files', type: String, multiple: true, defaultOption: true },
+        { name: 'help', alias: 'h', type: Boolean },
+        { name: 'ignoreexternal', type: Boolean },
+        { name: 'lib', type: Boolean },
+        { name: 'outputjson', type: Boolean },
+        { name: 'project', alias: 'p', type: String },
+        { name: 'pythonplatform', type: String },
+        { name: 'pythonversion', type: String },
+        { name: 'skipunannotated', type: Boolean },
+        { name: 'stats', type: Boolean },
+        { name: 'typeshed-path', alias: 't', type: String },
+        { name: 'venv-path', alias: 'v', type: String },
+        { name: 'verifytypes', type: String },
+        { name: 'verbose', type: Boolean },
+        { name: 'version', type: Boolean },
+        { name: 'warnings', type: Boolean },
+        { name: 'watch', alias: 'w', type: Boolean },
+    ];
+    let args;
+    try {
+        args = (0, command_line_args_1.default)(optionDefinitions);
+    }
+    catch (e) {
+        const argErr = e;
+        if (argErr && argErr.optionName) {
+            console.error(`Unexpected option ${argErr.optionName}.\n${toolName} --help for usage`);
+            return ExitStatus.ParameterError;
+        }
+        console.error(`Unexpected error\n${toolName} --help for usage`);
+        return ExitStatus.ParameterError;
+    }
+    if (args.help !== undefined) {
+        printUsage();
+        return ExitStatus.NoErrors;
+    }
+    if (args.version !== undefined) {
+        printVersion();
+        return ExitStatus.NoErrors;
+    }
+    for (const [arg, value] of Object.entries(args)) {
+        if (value === null) {
+            console.error(`'${arg}' option requires a value`);
+            return ExitStatus.ParameterError;
+        }
+    }
+    if (args.outputjson) {
+        const incompatibleArgs = ['stats', 'verbose', 'createstub', 'dependencies'];
+        for (const arg of incompatibleArgs) {
+            if (args[arg] !== undefined) {
+                console.error(`'outputjson' option cannot be used with '${arg}' option`);
+                return ExitStatus.ParameterError;
+            }
+        }
+    }
+    if (args['verifytypes'] !== undefined) {
+        const incompatibleArgs = ['watch', 'stats', 'createstub', 'dependencies', 'skipunannotated'];
+        for (const arg of incompatibleArgs) {
+            if (args[arg] !== undefined) {
+                console.error(`'verifytypes' option cannot be used with '${arg}' option`);
+                return ExitStatus.ParameterError;
+            }
+        }
+    }
+    if (args.createstub) {
+        const incompatibleArgs = ['watch', 'stats', 'verifytypes', 'dependencies', 'skipunannotated'];
+        for (const arg of incompatibleArgs) {
+            if (args[arg] !== undefined) {
+                console.error(`'createstub' option cannot be used with '${arg}' option`);
+                return ExitStatus.ParameterError;
+            }
+        }
+    }
+    const options = new commandLineOptions_1.CommandLineOptions(process.cwd(), false);
+    // Assume any relative paths are relative to the working directory.
+    if (args.files && Array.isArray(args.files)) {
+        options.fileSpecs = args.files;
+        options.fileSpecs = options.fileSpecs.map((f) => (0, pathUtils_1.combinePaths)(process.cwd(), f));
+    }
+    else {
+        options.fileSpecs = [];
+    }
+    if (args.project) {
+        options.configFilePath = (0, pathUtils_1.combinePaths)(process.cwd(), (0, pathUtils_1.normalizePath)(args.project));
+    }
+    if (args.pythonplatform) {
+        if (args.pythonplatform === 'Darwin' || args.pythonplatform === 'Linux' || args.pythonplatform === 'Windows') {
+            options.pythonPlatform = args.pythonplatform;
+        }
+        else {
+            console.error(`'${args.pythonplatform}' is not a supported Python platform; specify Darwin, Linux, or Windows`);
+            return ExitStatus.ParameterError;
+        }
+    }
+    if (args.pythonversion) {
+        const version = (0, pythonVersion_1.versionFromString)(args.pythonversion);
+        if (version) {
+            options.pythonVersion = version;
+        }
+        else {
+            console.error(`'${args.pythonversion}' is not a supported Python version; specify 3.3, 3.4, etc.`);
+            return ExitStatus.ParameterError;
+        }
+    }
+    if (args['venv-path']) {
+        options.venvPath = (0, pathUtils_1.combinePaths)(process.cwd(), (0, pathUtils_1.normalizePath)(args['venv-path']));
+    }
+    if (args['typeshed-path']) {
+        options.typeshedPath = (0, pathUtils_1.combinePaths)(process.cwd(), (0, pathUtils_1.normalizePath)(args['typeshed-path']));
+    }
+    if (args.createstub) {
+        options.typeStubTargetImportName = args.createstub;
+    }
+    options.analyzeUnannotatedFunctions = !args.skipunannotated;
+    if (args.verbose) {
+        options.verboseOutput = true;
+    }
+    if (args.lib) {
+        options.useLibraryCodeForTypes = true;
+    }
+    options.checkOnlyOpenFiles = false;
+    if (!!args.stats && !!args.verbose) {
+        options.logTypeEvaluationTime = true;
+    }
+    const treatWarningsAsErrors = !!args.warnings;
+    const logLevel = options.logTypeEvaluationTime ? console_1.LogLevel.Log : console_1.LogLevel.Error;
+    // If using outputjson, redirect all console output to stderr so it doesn't mess
+    // up the JSON output, which goes to stdout.
+    const output = args.outputjson ? new console_1.StderrConsoleWithLevel(logLevel) : new console_1.StandardConsoleWithLevel(logLevel);
+    const fileSystem = new pyrightFileSystem_1.PyrightFileSystem((0, realFileSystem_1.createFromRealFileSystem)(output, new chokidarFileWatcherProvider_1.ChokidarFileWatcherProvider(output)));
+    // The package type verification uses a different path.
+    if (args['verifytypes'] !== undefined) {
+        return verifyPackageTypes(fileSystem, args['verifytypes'] || '', !!args.verbose, !!args.outputjson, args['ignoreexternal']);
+    }
+    else if (args['ignoreexternal'] !== undefined) {
+        console.error(`'--ignoreexternal' is valid only when used with '--verifytypes'`);
+        return ExitStatus.ParameterError;
+    }
+    const watch = args.watch !== undefined;
+    options.watchForSourceChanges = watch;
+    options.watchForConfigChanges = watch;
+    const service = new service_1.AnalyzerService('<default>', fileSystem, output, () => new fullAccessHost_1.FullAccessHost(fileSystem));
+    const exitStatus = (0, deferred_1.createDeferred)();
+    service.setCompletionCallback((results) => {
+        if (results.fatalErrorOccurred) {
+            exitStatus.resolve(ExitStatus.FatalError);
+            return;
+        }
+        if (results.configParseErrorOccurred) {
+            exitStatus.resolve(ExitStatus.ConfigFileParseError);
+            return;
+        }
+        let errorCount = 0;
+        if (results.diagnostics.length > 0 && !args.createstub && !args['verifytypes']) {
+            if (args.outputjson) {
+                const report = reportDiagnosticsAsJson(results.diagnostics, results.filesInProgram, results.elapsedTime);
+                errorCount += report.errorCount;
+                if (treatWarningsAsErrors) {
+                    errorCount += report.warningCount;
+                }
+            }
+            else {
+                printVersion();
+                const report = reportDiagnosticsAsText(results.diagnostics);
+                errorCount += report.errorCount;
+                if (treatWarningsAsErrors) {
+                    errorCount += report.warningCount;
+                }
+            }
+        }
+        if (args.createstub && results.filesRequiringAnalysis === 0) {
+            try {
+                service.writeTypeStub(cancellationNone);
+                service.dispose();
+                console.log(`Type stub was created for '${args.createstub}'`);
+            }
+            catch (err) {
+                let errMessage = '';
+                if (err instanceof Error) {
+                    errMessage = ': ' + err.message;
+                }
+                console.error(`Error occurred when creating type stub: ` + errMessage);
+                exitStatus.resolve(ExitStatus.FatalError);
+                return;
+            }
+            exitStatus.resolve(ExitStatus.NoErrors);
+            return;
+        }
+        if (!args.outputjson) {
+            if (!watch) {
+                // Print the total time.
+                timing_1.timingStats.printSummary(console);
+            }
+            if (args.stats) {
+                // Print the stats details.
+                service.printStats();
+                timing_1.timingStats.printDetails(console);
+                if (args.verbose) {
+                    service.printDetailedAnalysisTimes();
+                }
+            }
+            if (args.dependencies) {
+                service.printDependencies(!!args.verbose);
+            }
+        }
+        if (!watch) {
+            exitStatus.resolve(errorCount > 0 ? ExitStatus.ErrorsReported : ExitStatus.NoErrors);
+            return;
+        }
+        else if (!args.outputjson) {
+            console.log('Watching for file changes...');
+        }
+    });
+    // This will trigger the analyzer.
+    service.setOptions(options);
+    return await exitStatus.promise;
+}
+function verifyPackageTypes(fileSystem, packageName, verboseOutput, outputJson, ignoreUnknownTypesFromImports) {
+    try {
+        const verifier = new packageTypeVerifier_1.PackageTypeVerifier(fileSystem, packageName, ignoreUnknownTypesFromImports);
+        const report = verifier.verify();
+        const jsonReport = buildTypeCompletenessReport(packageName, report);
+        if (outputJson) {
+            console.log(JSON.stringify(jsonReport, /* replacer */ undefined, 4));
+        }
+        else {
+            printTypeCompletenessReportText(jsonReport, verboseOutput);
+        }
+        return jsonReport.typeCompleteness.completenessScore < 1 ? ExitStatus.ErrorsReported : ExitStatus.NoErrors;
+    }
+    catch (err) {
+        let errMessage = '';
+        if (err instanceof Error) {
+            errMessage = ': ' + err.message;
+        }
+        console.error(`Error occurred when verifying types: ` + errMessage);
+        return ExitStatus.FatalError;
+    }
+}
+function accumulateReportDiagnosticStats(diag, report) {
+    if (diag.severity === 'error') {
+        report.summary.errorCount++;
+    }
+    else if (diag.severity === 'warning') {
+        report.summary.warningCount++;
+    }
+    else if (diag.severity === 'information') {
+        report.summary.informationCount++;
+    }
+}
+function buildTypeCompletenessReport(packageName, completenessReport) {
+    const report = {
+        version: getVersionString(),
+        time: Date.now().toString(),
+        generalDiagnostics: [],
+        summary: {
+            filesAnalyzed: completenessReport.modules.size,
+            errorCount: 0,
+            warningCount: 0,
+            informationCount: 0,
+            timeInSec: timing_1.timingStats.getTotalDuration(),
+        },
+    };
+    // Add the general diagnostics.
+    completenessReport.generalDiagnostics.forEach((diag) => {
+        const jsonDiag = convertDiagnosticToJson('', diag);
+        report.generalDiagnostics.push(jsonDiag);
+        accumulateReportDiagnosticStats(jsonDiag, report);
+    });
+    report.typeCompleteness = {
+        packageName,
+        packageRootDirectory: completenessReport.packageRootDirectory,
+        moduleName: completenessReport.moduleName,
+        moduleRootDirectory: completenessReport.moduleRootDirectory,
+        ignoreUnknownTypesFromImports: completenessReport.ignoreExternal,
+        pyTypedPath: completenessReport.pyTypedPath,
+        exportedSymbolCounts: {
+            withKnownType: 0,
+            withAmbiguousType: 0,
+            withUnknownType: 0,
+        },
+        otherSymbolCounts: {
+            withKnownType: 0,
+            withAmbiguousType: 0,
+            withUnknownType: 0,
+        },
+        missingFunctionDocStringCount: completenessReport.missingFunctionDocStringCount,
+        missingClassDocStringCount: completenessReport.missingClassDocStringCount,
+        missingDefaultParamCount: completenessReport.missingDefaultParamCount,
+        completenessScore: 0,
+        modules: [],
+        symbols: [],
+    };
+    // Add the modules.
+    completenessReport.modules.forEach((module) => {
+        const jsonModule = {
+            name: module.name,
+        };
+        report.typeCompleteness.modules.push(jsonModule);
+    });
+    // Add the symbols.
+    completenessReport.symbols.forEach((symbol) => {
+        const jsonSymbol = {
+            category: packageTypeVerifier_1.PackageTypeVerifier.getSymbolCategoryString(symbol.category),
+            name: symbol.fullName,
+            referenceCount: symbol.referenceCount,
+            isExported: symbol.isExported,
+            isTypeKnown: symbol.typeKnownStatus === 0 /* Known */,
+            isTypeAmbiguous: symbol.typeKnownStatus === 1 /* Ambiguous */,
+            diagnostics: symbol.diagnostics.map((diag) => convertDiagnosticToJson(diag.filePath, diag.diagnostic)),
+        };
+        const alternateNames = completenessReport.alternateSymbolNames.get(symbol.fullName);
+        if (alternateNames) {
+            jsonSymbol.alternateNames = alternateNames;
+        }
+        report.typeCompleteness.symbols.push(jsonSymbol);
+        // Accumulate counts for report.
+        if (symbol.typeKnownStatus === 0 /* Known */) {
+            if (symbol.isExported) {
+                report.typeCompleteness.exportedSymbolCounts.withKnownType++;
+            }
+            else {
+                report.typeCompleteness.otherSymbolCounts.withKnownType++;
+            }
+        }
+        else if (symbol.typeKnownStatus === 1 /* Ambiguous */) {
+            if (symbol.isExported) {
+                report.typeCompleteness.exportedSymbolCounts.withAmbiguousType++;
+            }
+            else {
+                report.typeCompleteness.otherSymbolCounts.withAmbiguousType++;
+            }
+        }
+        else {
+            if (symbol.isExported) {
+                report.typeCompleteness.exportedSymbolCounts.withUnknownType++;
+            }
+            else {
+                report.typeCompleteness.otherSymbolCounts.withUnknownType++;
+            }
+        }
+    });
+    const unknownSymbolCount = report.typeCompleteness.exportedSymbolCounts.withUnknownType;
+    const ambiguousSymbolCount = report.typeCompleteness.exportedSymbolCounts.withAmbiguousType;
+    const knownSymbolCount = report.typeCompleteness.exportedSymbolCounts.withKnownType;
+    const totalSymbolCount = unknownSymbolCount + ambiguousSymbolCount + knownSymbolCount;
+    if (totalSymbolCount > 0) {
+        report.typeCompleteness.completenessScore = knownSymbolCount / totalSymbolCount;
+    }
+    return report;
+}
+function printTypeCompletenessReportText(results, verboseOutput) {
+    const completenessReport = results.typeCompleteness;
+    console.log(`Module name: "${completenessReport.moduleName}"`);
+    if (completenessReport.packageRootDirectory !== undefined) {
+        console.log(`Package directory: "${completenessReport.packageRootDirectory}"`);
+    }
+    if (completenessReport.moduleRootDirectory !== undefined) {
+        console.log(`Module directory: "${completenessReport.moduleRootDirectory}"`);
+    }
+    if (completenessReport.pyTypedPath !== undefined) {
+        console.log(`Path of py.typed file: "${completenessReport.pyTypedPath}"`);
+    }
+    // Print list of public modules.
+    if (completenessReport.modules.length > 0) {
+        console.log('');
+        console.log(`Public modules: ${completenessReport.modules.length}`);
+        completenessReport.modules.forEach((module) => {
+            console.log(`   ${module.name}`);
+        });
+    }
+    // Print list of all symbols.
+    if (completenessReport.symbols.length > 0 && verboseOutput) {
+        console.log('');
+        console.log(`Exported symbols: ${completenessReport.symbols.filter((sym) => sym.isExported).length}`);
+        completenessReport.symbols.forEach((symbol) => {
+            if (symbol.isExported) {
+                const refCount = symbol.referenceCount > 1 ? ` (${symbol.referenceCount} references)` : '';
+                console.log(`   ${symbol.name}${refCount}`);
+            }
+        });
+        console.log('');
+        console.log(`Other referenced symbols: ${completenessReport.symbols.filter((sym) => !sym.isExported).length}`);
+        completenessReport.symbols.forEach((symbol) => {
+            if (!symbol.isExported) {
+                const refCount = symbol.referenceCount > 1 ? ` (${symbol.referenceCount} references)` : '';
+                console.log(`   ${symbol.name}${refCount}`);
+            }
+        });
+    }
+    // Print all the general diagnostics.
+    results.generalDiagnostics.forEach((diag) => {
+        logDiagnosticToConsole(diag);
+    });
+    // Print all the symbol-specific diagnostics.
+    console.log('');
+    console.log(`Symbols used in public interface:`);
+    results.typeCompleteness.symbols.forEach((symbol) => {
+        let diagnostics = symbol.diagnostics;
+        if (!verboseOutput) {
+            diagnostics = diagnostics.filter((diag) => diag.severity === 'error');
+        }
+        if (diagnostics.length > 0) {
+            console.log(`${symbol.name}`);
+            diagnostics.forEach((diag) => {
+                logDiagnosticToConsole(diag);
+            });
+        }
+    });
+    // Print other stats.
+    console.log('');
+    console.log(`Symbols exported by "${completenessReport.packageName}": ${completenessReport.exportedSymbolCounts.withKnownType +
+        completenessReport.exportedSymbolCounts.withAmbiguousType +
+        completenessReport.exportedSymbolCounts.withUnknownType}`);
+    console.log(`  With known type: ${completenessReport.exportedSymbolCounts.withKnownType}`);
+    console.log(`  With ambiguous type: ${completenessReport.exportedSymbolCounts.withAmbiguousType}`);
+    console.log(`  With unknown type: ${completenessReport.exportedSymbolCounts.withUnknownType}`);
+    if (completenessReport.ignoreUnknownTypesFromImports) {
+        console.log(`    (Ignoring unknown types imported from other packages)`);
+    }
+    console.log(`  Functions without docstring: ${completenessReport.missingFunctionDocStringCount}`);
+    console.log(`  Functions without default param: ${completenessReport.missingDefaultParamCount}`);
+    console.log(`  Classes without docstring: ${completenessReport.missingClassDocStringCount}`);
+    console.log('');
+    console.log(`Other symbols referenced but not exported by "${completenessReport.packageName}": ${completenessReport.otherSymbolCounts.withKnownType +
+        completenessReport.otherSymbolCounts.withAmbiguousType +
+        completenessReport.otherSymbolCounts.withUnknownType}`);
+    console.log(`  With known type: ${completenessReport.otherSymbolCounts.withKnownType}`);
+    console.log(`  With ambiguous type: ${completenessReport.otherSymbolCounts.withAmbiguousType}`);
+    console.log(`  With unknown type: ${completenessReport.otherSymbolCounts.withUnknownType}`);
+    console.log('');
+    console.log(`Type completeness score: ${Math.round(completenessReport.completenessScore * 1000) / 10}%`);
+    console.log('');
+    console.info(`Completed in ${results.summary.timeInSec}sec`);
+    console.log('');
+}
+function printUsage() {
+    console.log('Usage: ' +
+        toolName +
+        ' [options] files...\n' +
+        '  Options:\n' +
+        '  --createstub <IMPORT>              Create type stub file(s) for import\n' +
+        '  --dependencies                     Emit import dependency information\n' +
+        '  -h,--help                          Show this help message\n' +
+        '  --ignoreexternal                   Ignore external imports for --verifytypes\n' +
+        '  --lib                              Use library code to infer types when stubs are missing\n' +
+        '  --outputjson                       Output results in JSON format\n' +
+        '  -p,--project <FILE OR DIRECTORY>   Use the configuration file at this location\n' +
+        '  --pythonplatform <PLATFORM>        Analyze for a specific platform (Darwin, Linux, Windows)\n' +
+        '  --pythonversion <VERSION>          Analyze for a specific version (3.3, 3.4, etc.)\n' +
+        '  --skipunannotated                  Skip analysis of functions with no type annotations\n' +
+        '  --stats                            Print detailed performance stats\n' +
+        '  -t,--typeshed-path <DIRECTORY>     Use typeshed type stubs at this location\n' +
+        '  -v,--venv-path <DIRECTORY>         Directory that contains virtual environments\n' +
+        '  --verbose                          Emit verbose diagnostics\n' +
+        '  --verifytypes <PACKAGE>            Verify type completeness of a py.typed package\n' +
+        '  --version                          Print Pyright version\n' +
+        '  --warnings                         Use exit code of 1 if warnings are reported\n' +
+        '  -w,--watch                         Continue to run and watch for changes\n');
+}
+function getVersionString() {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const version = require('../package.json').version;
+    return version.toString();
+}
+function printVersion() {
+    console.log(`${toolName} ${getVersionString()}`);
+}
+function reportDiagnosticsAsJson(fileDiagnostics, filesInProgram, timeInSec) {
+    const report = {
+        version: getVersionString(),
+        time: Date.now().toString(),
+        generalDiagnostics: [],
+        summary: {
+            filesAnalyzed: filesInProgram,
+            errorCount: 0,
+            warningCount: 0,
+            informationCount: 0,
+            timeInSec,
+        },
+    };
+    fileDiagnostics.forEach((fileDiag) => {
+        fileDiag.diagnostics.forEach((diag) => {
+            if (diag.category === 0 /* Error */ ||
+                diag.category === 1 /* Warning */ ||
+                diag.category === 2 /* Information */) {
+                const jsonDiag = convertDiagnosticToJson(fileDiag.filePath, diag);
+                report.generalDiagnostics.push(jsonDiag);
+                accumulateReportDiagnosticStats(jsonDiag, report);
+            }
+        });
+    });
+    console.log(JSON.stringify(report, /* replacer */ undefined, 4));
+    return {
+        errorCount: report.summary.errorCount,
+        warningCount: report.summary.warningCount,
+        informationCount: report.summary.informationCount,
+        diagnosticCount: report.summary.errorCount + report.summary.warningCount + report.summary.informationCount,
+    };
+}
+function convertDiagnosticToJson(filePath, diag) {
+    return {
+        file: filePath,
+        severity: diag.category === 0 /* Error */
+            ? 'error'
+            : diag.category === 1 /* Warning */
+                ? 'warning'
+                : 'information',
+        message: diag.message,
+        range: (0, textRange_1.isEmptyRange)(diag.range) ? undefined : diag.range,
+        rule: diag.getRule(),
+    };
+}
+function reportDiagnosticsAsText(fileDiagnostics) {
+    let errorCount = 0;
+    let warningCount = 0;
+    let informationCount = 0;
+    fileDiagnostics.forEach((fileDiagnostics) => {
+        // Don't report unused code or deprecated diagnostics.
+        const fileErrorsAndWarnings = fileDiagnostics.diagnostics.filter((diag) => diag.category !== 3 /* UnusedCode */ && diag.category !== 4 /* Deprecated */);
+        if (fileErrorsAndWarnings.length > 0) {
+            console.log(`${fileDiagnostics.filePath}`);
+            fileErrorsAndWarnings.forEach((diag) => {
+                logDiagnosticToConsole(convertDiagnosticToJson(fileDiagnostics.filePath, diag));
+                if (diag.category === 0 /* Error */) {
+                    errorCount++;
+                }
+                else if (diag.category === 1 /* Warning */) {
+                    warningCount++;
+                }
+                else if (diag.category === 2 /* Information */) {
+                    informationCount++;
+                }
+            });
+        }
+    });
+    console.log(`${errorCount.toString()} ${errorCount === 1 ? 'error' : 'errors'}, ` +
+        `${warningCount.toString()} ${warningCount === 1 ? 'warning' : 'warnings'}, ` +
+        `${informationCount.toString()} ${informationCount === 1 ? 'information' : 'informations'} `);
+    return {
+        errorCount,
+        warningCount,
+        informationCount,
+        diagnosticCount: errorCount + warningCount + informationCount,
+    };
+}
+function logDiagnosticToConsole(diag, prefix = '  ') {
+    let message = prefix;
+    if (diag.file) {
+        message += `${diag.file}:`;
+    }
+    if (diag.range && !(0, textRange_1.isEmptyRange)(diag.range)) {
+        message +=
+            chalk_1.default.yellow(`${diag.range.start.line + 1}`) +
+                ':' +
+                chalk_1.default.yellow(`${diag.range.start.character + 1}`) +
+                ' - ';
+    }
+    const [firstLine, ...remainingLines] = diag.message.split('\n');
+    message +=
+        diag.severity === 'error'
+            ? chalk_1.default.red('error')
+            : diag.severity === 'warning'
+                ? chalk_1.default.cyan('warning')
+                : chalk_1.default.blue('information');
+    message += `: ${firstLine}`;
+    if (remainingLines.length > 0) {
+        message += '\n' + prefix + remainingLines.join('\n' + prefix);
+    }
+    if (diag.rule) {
+        message += chalk_1.default.gray(` (${diag.rule})`);
+    }
+    console.log(message);
+}
+// Increase the default stack trace limit from 16 to 64 to help diagnose
+// crashes with deep stack traces.
+Error.stackTraceLimit = 64;
+async function main() {
+    if (process.env.NODE_ENV === 'production') {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        require('source-map-support').install();
+    }
+    const exitCode = await processArgs();
+    process.exitCode = exitCode;
+    // Don't call process.exit; stdout may not have been flushed which can break readers.
+    // https://github.com/nodejs/node/issues/6379
+    // https://github.com/nodejs/node/issues/6456
+    // https://github.com/nodejs/node/issues/19218
+}
+exports.main = main;
+//# sourceMappingURL=pyright.js.map