@zzzen/pyright-internal 1.1.254

package/dist/common/configOptions.js

@@ -0,0 +1,908 @@
+"use strict";
+/*
+ * configOptions.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ * Author: Eric Traut
+ *
+ * Class that holds the configuration options for the analyzer.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigOptions = exports.getStrictDiagnosticRuleSet = exports.getBasicDiagnosticRuleSet = exports.getOffDiagnosticRuleSet = exports.getStrictModeNotOverriddenRules = exports.getDiagLevelDiagnosticRules = exports.getBooleanDiagnosticRules = exports.cloneDiagnosticRuleSet = exports.ExecutionEnvironment = exports.PythonPlatform = void 0;
+const path_1 = require("path");
+const pythonPathUtils_1 = require("../analyzer/pythonPathUtils");
+const pathConsts = __importStar(require("../common/pathConsts"));
+const collectionUtils_1 = require("./collectionUtils");
+const diagnosticRules_1 = require("./diagnosticRules");
+const pathUtils_1 = require("./pathUtils");
+const pythonVersion_1 = require("./pythonVersion");
+var PythonPlatform;
+(function (PythonPlatform) {
+    PythonPlatform["Darwin"] = "Darwin";
+    PythonPlatform["Windows"] = "Windows";
+    PythonPlatform["Linux"] = "Linux";
+})(PythonPlatform = exports.PythonPlatform || (exports.PythonPlatform = {}));
+class ExecutionEnvironment {
+    // Default to "." which indicates every file in the project.
+    constructor(root, defaultPythonVersion, defaultPythonPlatform, defaultExtraPaths) {
+        // Default to no extra paths.
+        this.extraPaths = [];
+        this.root = root || undefined;
+        this.pythonVersion = defaultPythonVersion || pythonVersion_1.latestStablePythonVersion;
+        this.pythonPlatform = defaultPythonPlatform;
+        this.extraPaths = [...(defaultExtraPaths !== null && defaultExtraPaths !== void 0 ? defaultExtraPaths : [])];
+    }
+}
+exports.ExecutionEnvironment = ExecutionEnvironment;
+function cloneDiagnosticRuleSet(diagSettings) {
+    // Create a shallow copy of the existing object.
+    return Object.assign({}, diagSettings);
+}
+exports.cloneDiagnosticRuleSet = cloneDiagnosticRuleSet;
+// Returns a list of the diagnostic rules that are configured with
+// a true or false value.
+function getBooleanDiagnosticRules(includeNonOverridable = false) {
+    const boolRules = [
+        diagnosticRules_1.DiagnosticRule.strictListInference,
+        diagnosticRules_1.DiagnosticRule.strictSetInference,
+        diagnosticRules_1.DiagnosticRule.strictDictionaryInference,
+        diagnosticRules_1.DiagnosticRule.strictParameterNoneValue,
+    ];
+    if (includeNonOverridable) {
+        // Do not include this this one because we don't
+        // want to override it in strict mode or support
+        // it within pyright comments.
+        boolRules.push(diagnosticRules_1.DiagnosticRule.enableTypeIgnoreComments);
+    }
+    return boolRules;
+}
+exports.getBooleanDiagnosticRules = getBooleanDiagnosticRules;
+// Returns a list of the diagnostic rules that are configured with
+// a diagnostic level ('none', 'error', etc.).
+function getDiagLevelDiagnosticRules() {
+    return [
+        diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues,
+        diagnosticRules_1.DiagnosticRule.reportPropertyTypeMismatch,
+        diagnosticRules_1.DiagnosticRule.reportFunctionMemberAccess,
+        diagnosticRules_1.DiagnosticRule.reportMissingImports,
+        diagnosticRules_1.DiagnosticRule.reportMissingModuleSource,
+        diagnosticRules_1.DiagnosticRule.reportMissingTypeStubs,
+        diagnosticRules_1.DiagnosticRule.reportImportCycles,
+        diagnosticRules_1.DiagnosticRule.reportUnusedImport,
+        diagnosticRules_1.DiagnosticRule.reportUnusedClass,
+        diagnosticRules_1.DiagnosticRule.reportUnusedFunction,
+        diagnosticRules_1.DiagnosticRule.reportUnusedVariable,
+        diagnosticRules_1.DiagnosticRule.reportDuplicateImport,
+        diagnosticRules_1.DiagnosticRule.reportWildcardImportFromLibrary,
+        diagnosticRules_1.DiagnosticRule.reportOptionalSubscript,
+        diagnosticRules_1.DiagnosticRule.reportOptionalMemberAccess,
+        diagnosticRules_1.DiagnosticRule.reportOptionalCall,
+        diagnosticRules_1.DiagnosticRule.reportOptionalIterable,
+        diagnosticRules_1.DiagnosticRule.reportOptionalContextManager,
+        diagnosticRules_1.DiagnosticRule.reportOptionalOperand,
+        diagnosticRules_1.DiagnosticRule.reportTypedDictNotRequiredAccess,
+        diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator,
+        diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator,
+        diagnosticRules_1.DiagnosticRule.reportUntypedBaseClass,
+        diagnosticRules_1.DiagnosticRule.reportUntypedNamedTuple,
+        diagnosticRules_1.DiagnosticRule.reportPrivateUsage,
+        diagnosticRules_1.DiagnosticRule.reportTypeCommentUsage,
+        diagnosticRules_1.DiagnosticRule.reportPrivateImportUsage,
+        diagnosticRules_1.DiagnosticRule.reportConstantRedefinition,
+        diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride,
+        diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride,
+        diagnosticRules_1.DiagnosticRule.reportInconsistentConstructor,
+        diagnosticRules_1.DiagnosticRule.reportOverlappingOverload,
+        diagnosticRules_1.DiagnosticRule.reportMissingSuperCall,
+        diagnosticRules_1.DiagnosticRule.reportUninitializedInstanceVariable,
+        diagnosticRules_1.DiagnosticRule.reportInvalidStringEscapeSequence,
+        diagnosticRules_1.DiagnosticRule.reportUnknownParameterType,
+        diagnosticRules_1.DiagnosticRule.reportUnknownArgumentType,
+        diagnosticRules_1.DiagnosticRule.reportUnknownLambdaType,
+        diagnosticRules_1.DiagnosticRule.reportUnknownVariableType,
+        diagnosticRules_1.DiagnosticRule.reportUnknownMemberType,
+        diagnosticRules_1.DiagnosticRule.reportMissingParameterType,
+        diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument,
+        diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse,
+        diagnosticRules_1.DiagnosticRule.reportCallInDefaultInitializer,
+        diagnosticRules_1.DiagnosticRule.reportUnnecessaryIsInstance,
+        diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast,
+        diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison,
+        diagnosticRules_1.DiagnosticRule.reportAssertAlwaysTrue,
+        diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName,
+        diagnosticRules_1.DiagnosticRule.reportImplicitStringConcatenation,
+        diagnosticRules_1.DiagnosticRule.reportUndefinedVariable,
+        diagnosticRules_1.DiagnosticRule.reportUnboundVariable,
+        diagnosticRules_1.DiagnosticRule.reportInvalidStubStatement,
+        diagnosticRules_1.DiagnosticRule.reportIncompleteStub,
+        diagnosticRules_1.DiagnosticRule.reportUnsupportedDunderAll,
+        diagnosticRules_1.DiagnosticRule.reportUnusedCallResult,
+        diagnosticRules_1.DiagnosticRule.reportUnusedCoroutine,
+        diagnosticRules_1.DiagnosticRule.reportUnusedExpression,
+        diagnosticRules_1.DiagnosticRule.reportUnnecessaryTypeIgnoreComment,
+        diagnosticRules_1.DiagnosticRule.reportMatchNotExhaustive,
+    ];
+}
+exports.getDiagLevelDiagnosticRules = getDiagLevelDiagnosticRules;
+function getStrictModeNotOverriddenRules() {
+    // In strict mode, the value in the user config file should be honored and
+    // not overwritten by the value from the strict rule set.
+    return [diagnosticRules_1.DiagnosticRule.reportMissingModuleSource];
+}
+exports.getStrictModeNotOverriddenRules = getStrictModeNotOverriddenRules;
+function getOffDiagnosticRuleSet() {
+    const diagSettings = {
+        printUnknownAsAny: true,
+        omitTypeArgsIfAny: true,
+        omitUnannotatedParamType: true,
+        omitConditionalConstraint: true,
+        pep604Printing: true,
+        strictListInference: false,
+        strictSetInference: false,
+        strictDictionaryInference: false,
+        strictParameterNoneValue: true,
+        enableTypeIgnoreComments: true,
+        reportGeneralTypeIssues: 'none',
+        reportPropertyTypeMismatch: 'none',
+        reportFunctionMemberAccess: 'none',
+        reportMissingImports: 'warning',
+        reportMissingModuleSource: 'warning',
+        reportMissingTypeStubs: 'none',
+        reportImportCycles: 'none',
+        reportUnusedImport: 'none',
+        reportUnusedClass: 'none',
+        reportUnusedFunction: 'none',
+        reportUnusedVariable: 'none',
+        reportDuplicateImport: 'none',
+        reportWildcardImportFromLibrary: 'none',
+        reportOptionalSubscript: 'none',
+        reportOptionalMemberAccess: 'none',
+        reportOptionalCall: 'none',
+        reportOptionalIterable: 'none',
+        reportOptionalContextManager: 'none',
+        reportOptionalOperand: 'none',
+        reportTypedDictNotRequiredAccess: 'none',
+        reportUntypedFunctionDecorator: 'none',
+        reportUntypedClassDecorator: 'none',
+        reportUntypedBaseClass: 'none',
+        reportUntypedNamedTuple: 'none',
+        reportPrivateUsage: 'none',
+        reportTypeCommentUsage: 'none',
+        reportPrivateImportUsage: 'none',
+        reportConstantRedefinition: 'none',
+        reportIncompatibleMethodOverride: 'none',
+        reportIncompatibleVariableOverride: 'none',
+        reportInconsistentConstructor: 'none',
+        reportOverlappingOverload: 'none',
+        reportMissingSuperCall: 'none',
+        reportUninitializedInstanceVariable: 'none',
+        reportInvalidStringEscapeSequence: 'none',
+        reportUnknownParameterType: 'none',
+        reportUnknownArgumentType: 'none',
+        reportUnknownLambdaType: 'none',
+        reportUnknownVariableType: 'none',
+        reportUnknownMemberType: 'none',
+        reportMissingParameterType: 'none',
+        reportMissingTypeArgument: 'none',
+        reportInvalidTypeVarUse: 'none',
+        reportCallInDefaultInitializer: 'none',
+        reportUnnecessaryIsInstance: 'none',
+        reportUnnecessaryCast: 'none',
+        reportUnnecessaryComparison: 'none',
+        reportAssertAlwaysTrue: 'none',
+        reportSelfClsParameterName: 'none',
+        reportImplicitStringConcatenation: 'none',
+        reportUnboundVariable: 'none',
+        reportUndefinedVariable: 'warning',
+        reportInvalidStubStatement: 'none',
+        reportIncompleteStub: 'none',
+        reportUnsupportedDunderAll: 'none',
+        reportUnusedCallResult: 'none',
+        reportUnusedCoroutine: 'none',
+        reportUnusedExpression: 'none',
+        reportUnnecessaryTypeIgnoreComment: 'none',
+        reportMatchNotExhaustive: 'none',
+    };
+    return diagSettings;
+}
+exports.getOffDiagnosticRuleSet = getOffDiagnosticRuleSet;
+function getBasicDiagnosticRuleSet() {
+    const diagSettings = {
+        printUnknownAsAny: false,
+        omitTypeArgsIfAny: false,
+        omitUnannotatedParamType: true,
+        omitConditionalConstraint: false,
+        pep604Printing: true,
+        strictListInference: false,
+        strictSetInference: false,
+        strictDictionaryInference: false,
+        strictParameterNoneValue: true,
+        enableTypeIgnoreComments: true,
+        reportGeneralTypeIssues: 'error',
+        reportPropertyTypeMismatch: 'none',
+        reportFunctionMemberAccess: 'none',
+        reportMissingImports: 'error',
+        reportMissingModuleSource: 'warning',
+        reportMissingTypeStubs: 'none',
+        reportImportCycles: 'none',
+        reportUnusedImport: 'none',
+        reportUnusedClass: 'none',
+        reportUnusedFunction: 'none',
+        reportUnusedVariable: 'none',
+        reportDuplicateImport: 'none',
+        reportWildcardImportFromLibrary: 'warning',
+        reportOptionalSubscript: 'error',
+        reportOptionalMemberAccess: 'error',
+        reportOptionalCall: 'error',
+        reportOptionalIterable: 'error',
+        reportOptionalContextManager: 'error',
+        reportOptionalOperand: 'error',
+        reportTypedDictNotRequiredAccess: 'error',
+        reportUntypedFunctionDecorator: 'none',
+        reportUntypedClassDecorator: 'none',
+        reportUntypedBaseClass: 'none',
+        reportUntypedNamedTuple: 'none',
+        reportPrivateUsage: 'none',
+        reportTypeCommentUsage: 'none',
+        reportPrivateImportUsage: 'error',
+        reportConstantRedefinition: 'none',
+        reportIncompatibleMethodOverride: 'none',
+        reportIncompatibleVariableOverride: 'none',
+        reportInconsistentConstructor: 'none',
+        reportOverlappingOverload: 'none',
+        reportMissingSuperCall: 'none',
+        reportUninitializedInstanceVariable: 'none',
+        reportInvalidStringEscapeSequence: 'warning',
+        reportUnknownParameterType: 'none',
+        reportUnknownArgumentType: 'none',
+        reportUnknownLambdaType: 'none',
+        reportUnknownVariableType: 'none',
+        reportUnknownMemberType: 'none',
+        reportMissingParameterType: 'none',
+        reportMissingTypeArgument: 'none',
+        reportInvalidTypeVarUse: 'warning',
+        reportCallInDefaultInitializer: 'none',
+        reportUnnecessaryIsInstance: 'none',
+        reportUnnecessaryCast: 'none',
+        reportUnnecessaryComparison: 'none',
+        reportAssertAlwaysTrue: 'warning',
+        reportSelfClsParameterName: 'warning',
+        reportImplicitStringConcatenation: 'none',
+        reportUnboundVariable: 'error',
+        reportUndefinedVariable: 'error',
+        reportInvalidStubStatement: 'none',
+        reportIncompleteStub: 'none',
+        reportUnsupportedDunderAll: 'warning',
+        reportUnusedCallResult: 'none',
+        reportUnusedCoroutine: 'error',
+        reportUnusedExpression: 'warning',
+        reportUnnecessaryTypeIgnoreComment: 'none',
+        reportMatchNotExhaustive: 'none',
+    };
+    return diagSettings;
+}
+exports.getBasicDiagnosticRuleSet = getBasicDiagnosticRuleSet;
+function getStrictDiagnosticRuleSet() {
+    const diagSettings = {
+        printUnknownAsAny: false,
+        omitTypeArgsIfAny: false,
+        omitUnannotatedParamType: false,
+        omitConditionalConstraint: false,
+        pep604Printing: true,
+        strictListInference: true,
+        strictSetInference: true,
+        strictDictionaryInference: true,
+        strictParameterNoneValue: true,
+        enableTypeIgnoreComments: true,
+        reportGeneralTypeIssues: 'error',
+        reportPropertyTypeMismatch: 'none',
+        reportFunctionMemberAccess: 'error',
+        reportMissingImports: 'error',
+        reportMissingModuleSource: 'warning',
+        reportMissingTypeStubs: 'error',
+        reportImportCycles: 'error',
+        reportUnusedImport: 'error',
+        reportUnusedClass: 'error',
+        reportUnusedFunction: 'error',
+        reportUnusedVariable: 'error',
+        reportDuplicateImport: 'error',
+        reportWildcardImportFromLibrary: 'error',
+        reportOptionalSubscript: 'error',
+        reportOptionalMemberAccess: 'error',
+        reportOptionalCall: 'error',
+        reportOptionalIterable: 'error',
+        reportOptionalContextManager: 'error',
+        reportOptionalOperand: 'error',
+        reportTypedDictNotRequiredAccess: 'error',
+        reportUntypedFunctionDecorator: 'error',
+        reportUntypedClassDecorator: 'error',
+        reportUntypedBaseClass: 'error',
+        reportUntypedNamedTuple: 'error',
+        reportPrivateUsage: 'error',
+        reportTypeCommentUsage: 'error',
+        reportPrivateImportUsage: 'error',
+        reportConstantRedefinition: 'error',
+        reportIncompatibleMethodOverride: 'error',
+        reportIncompatibleVariableOverride: 'error',
+        reportInconsistentConstructor: 'error',
+        reportOverlappingOverload: 'error',
+        reportMissingSuperCall: 'none',
+        reportUninitializedInstanceVariable: 'none',
+        reportInvalidStringEscapeSequence: 'error',
+        reportUnknownParameterType: 'error',
+        reportUnknownArgumentType: 'error',
+        reportUnknownLambdaType: 'error',
+        reportUnknownVariableType: 'error',
+        reportUnknownMemberType: 'error',
+        reportMissingParameterType: 'error',
+        reportMissingTypeArgument: 'error',
+        reportInvalidTypeVarUse: 'error',
+        reportCallInDefaultInitializer: 'none',
+        reportUnnecessaryIsInstance: 'error',
+        reportUnnecessaryCast: 'error',
+        reportUnnecessaryComparison: 'error',
+        reportAssertAlwaysTrue: 'error',
+        reportSelfClsParameterName: 'error',
+        reportImplicitStringConcatenation: 'none',
+        reportUnboundVariable: 'error',
+        reportUndefinedVariable: 'error',
+        reportInvalidStubStatement: 'error',
+        reportIncompleteStub: 'error',
+        reportUnsupportedDunderAll: 'error',
+        reportUnusedCallResult: 'none',
+        reportUnusedCoroutine: 'error',
+        reportUnusedExpression: 'error',
+        reportUnnecessaryTypeIgnoreComment: 'none',
+        reportMatchNotExhaustive: 'error',
+    };
+    return diagSettings;
+}
+exports.getStrictDiagnosticRuleSet = getStrictDiagnosticRuleSet;
+// Internal configuration options. These are derived from a combination
+// of the command line and from a JSON-based config file.
+class ConfigOptions {
+    constructor(projectRoot, typeCheckingMode) {
+        // A list of file specs to include in the analysis. Can contain
+        // directories, in which case all "*.py" files within those directories
+        // are included.
+        this.include = [];
+        // A list of file specs to exclude from the analysis (overriding include
+        // if necessary). Can contain directories, in which case all "*.py" files
+        // within those directories are included.
+        this.exclude = [];
+        // A list of file specs whose errors and warnings should be ignored even
+        // if they are included in the transitive closure of included files.
+        this.ignore = [];
+        // A list of file specs that should be analyzed using "strict" mode.
+        this.strict = [];
+        // A set of defined constants that are used by the binder to determine
+        // whether runtime conditions should evaluate to True or False.
+        this.defineConstant = new Map();
+        // Offer auto-import completions.
+        this.autoImportCompletions = true;
+        // Use indexing.
+        this.indexing = false;
+        // Use type evaluator call tracking
+        this.logTypeEvaluationTime = false;
+        // Minimum threshold for type eval logging
+        this.typeEvaluationTimeThreshold = 50;
+        // Was this config initialized from JSON (pyrightconfig/pyproject)?
+        this.initializedFromJson = false;
+        // Should we skip analysis of all functions and methods that have
+        // no parameter ore return type annotations?
+        this.analyzeUnannotatedFunctions = true;
+        //---------------------------------------------------------------
+        // Parsing and Import Resolution Settings
+        // Parameters that specify the execution environment for
+        // the files being analyzed.
+        this.executionEnvironments = [];
+        this.projectRoot = projectRoot;
+        this.typeCheckingMode = typeCheckingMode;
+        this.diagnosticRuleSet = ConfigOptions.getDiagnosticRuleSet(typeCheckingMode);
+    }
+    static getDiagnosticRuleSet(typeCheckingMode) {
+        if (typeCheckingMode === 'strict') {
+            return getStrictDiagnosticRuleSet();
+        }
+        if (typeCheckingMode === 'off') {
+            return getOffDiagnosticRuleSet();
+        }
+        return getBasicDiagnosticRuleSet();
+    }
+    getDefaultExecEnvironment() {
+        return new ExecutionEnvironment(this.projectRoot, this.defaultPythonVersion, this.defaultPythonPlatform, this.defaultExtraPaths);
+    }
+    // Finds the best execution environment for a given file path. The
+    // specified file path should be absolute.
+    // If no matching execution environment can be found, a default
+    // execution environment is used.
+    findExecEnvironment(filePath) {
+        var _a;
+        return ((_a = this.executionEnvironments.find((env) => {
+            const envRoot = (0, pathUtils_1.ensureTrailingDirectorySeparator)((0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, env.root)));
+            return filePath.startsWith(envRoot);
+        })) !== null && _a !== void 0 ? _a : this.getDefaultExecEnvironment());
+    }
+    getExecutionEnvironments() {
+        if (this.executionEnvironments.length > 0) {
+            return this.executionEnvironments;
+        }
+        return [this.getDefaultExecEnvironment()];
+    }
+    // Initialize the structure from a JSON object.
+    initializeFromJson(configObj, typeCheckingMode, console, fs, host, diagnosticOverrides, skipIncludeSection = false) {
+        this.initializedFromJson = true;
+        // Read the "include" entry.
+        if (!skipIncludeSection) {
+            this.include = [];
+            if (configObj.include !== undefined) {
+                if (!Array.isArray(configObj.include)) {
+                    console.error(`Config "include" entry must must contain an array.`);
+                }
+                else {
+                    const filesList = configObj.include;
+                    filesList.forEach((fileSpec, index) => {
+                        if (typeof fileSpec !== 'string') {
+                            console.error(`Index ${index} of "include" array should be a string.`);
+                        }
+                        else if ((0, path_1.isAbsolute)(fileSpec)) {
+                            console.error(`Ignoring path "${fileSpec}" in "include" array because it is not relative.`);
+                        }
+                        else {
+                            this.include.push((0, pathUtils_1.getFileSpec)(fs, this.projectRoot, fileSpec));
+                        }
+                    });
+                }
+            }
+        }
+        // Read the "exclude" entry.
+        this.exclude = [];
+        if (configObj.exclude !== undefined) {
+            if (!Array.isArray(configObj.exclude)) {
+                console.error(`Config "exclude" entry must contain an array.`);
+            }
+            else {
+                const filesList = configObj.exclude;
+                filesList.forEach((fileSpec, index) => {
+                    if (typeof fileSpec !== 'string') {
+                        console.error(`Index ${index} of "exclude" array should be a string.`);
+                    }
+                    else if ((0, path_1.isAbsolute)(fileSpec)) {
+                        console.error(`Ignoring path "${fileSpec}" in "exclude" array because it is not relative.`);
+                    }
+                    else {
+                        this.exclude.push((0, pathUtils_1.getFileSpec)(fs, this.projectRoot, fileSpec));
+                    }
+                });
+            }
+        }
+        // Read the "ignore" entry.
+        this.ignore = [];
+        if (configObj.ignore !== undefined) {
+            if (!Array.isArray(configObj.ignore)) {
+                console.error(`Config "ignore" entry must contain an array.`);
+            }
+            else {
+                const filesList = configObj.ignore;
+                filesList.forEach((fileSpec, index) => {
+                    if (typeof fileSpec !== 'string') {
+                        console.error(`Index ${index} of "ignore" array should be a string.`);
+                    }
+                    else if ((0, path_1.isAbsolute)(fileSpec)) {
+                        console.error(`Ignoring path "${fileSpec}" in "ignore" array because it is not relative.`);
+                    }
+                    else {
+                        this.ignore.push((0, pathUtils_1.getFileSpec)(fs, this.projectRoot, fileSpec));
+                    }
+                });
+            }
+        }
+        // Read the "strict" entry.
+        this.strict = [];
+        if (configObj.strict !== undefined) {
+            if (!Array.isArray(configObj.strict)) {
+                console.error(`Config "strict" entry must contain an array.`);
+            }
+            else {
+                const filesList = configObj.strict;
+                filesList.forEach((fileSpec, index) => {
+                    if (typeof fileSpec !== 'string') {
+                        console.error(`Index ${index} of "strict" array should be a string.`);
+                    }
+                    else if ((0, path_1.isAbsolute)(fileSpec)) {
+                        console.error(`Ignoring path "${fileSpec}" in "strict" array because it is not relative.`);
+                    }
+                    else {
+                        this.strict.push((0, pathUtils_1.getFileSpec)(fs, this.projectRoot, fileSpec));
+                    }
+                });
+            }
+        }
+        // If there is a "typeCheckingMode", it can override the provided setting.
+        let configTypeCheckingMode;
+        if (configObj.typeCheckingMode !== undefined) {
+            if (configObj.typeCheckingMode === 'off' ||
+                configObj.typeCheckingMode === 'basic' ||
+                configObj.typeCheckingMode === 'strict') {
+                configTypeCheckingMode = configObj.typeCheckingMode;
+            }
+            else {
+                console.error(`Config "typeCheckingMode" entry must contain "off", "basic", or "strict".`);
+            }
+        }
+        if (configObj.useLibraryCodeForTypes !== undefined) {
+            if (typeof configObj.useLibraryCodeForTypes === 'boolean') {
+                this.useLibraryCodeForTypes = configObj.useLibraryCodeForTypes;
+            }
+            else {
+                console.error(`Config "useLibraryCodeForTypes" entry must be true or false.`);
+            }
+        }
+        this.typeCheckingMode = configTypeCheckingMode || typeCheckingMode;
+        const defaultSettings = ConfigOptions.getDiagnosticRuleSet(this.typeCheckingMode);
+        // Start with the default values for all rules in the rule set.
+        this.diagnosticRuleSet = { ...defaultSettings };
+        // Apply host-provided overrides.
+        this.applyDiagnosticOverrides(diagnosticOverrides);
+        // Apply overrides from the config file for the boolean rules.
+        getBooleanDiagnosticRules(/* includeNonOverridable */ true).forEach((ruleName) => {
+            this.diagnosticRuleSet[ruleName] = this._convertBoolean(configObj[ruleName], ruleName, this.diagnosticRuleSet[ruleName]);
+        });
+        // Apply overrides from the config file for the diagnostic level rules.
+        getDiagLevelDiagnosticRules().forEach((ruleName) => {
+            this.diagnosticRuleSet[ruleName] = this._convertDiagnosticLevel(configObj[ruleName], ruleName, this.diagnosticRuleSet[ruleName]);
+        });
+        // Read the "venvPath".
+        this.venvPath = undefined;
+        if (configObj.venvPath !== undefined) {
+            if (typeof configObj.venvPath !== 'string') {
+                console.error(`Config "venvPath" field must contain a string.`);
+            }
+            else {
+                this.venvPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, configObj.venvPath));
+            }
+        }
+        // Read the "venv" name.
+        this.venv = undefined;
+        if (configObj.venv !== undefined) {
+            if (typeof configObj.venv !== 'string') {
+                console.error(`Config "venv" field must contain a string.`);
+            }
+            else {
+                this.venv = configObj.venv;
+            }
+        }
+        // Read the default "extraPaths".
+        if (configObj.extraPaths !== undefined) {
+            this.defaultExtraPaths = [];
+            if (!Array.isArray(configObj.extraPaths)) {
+                console.error(`Config "extraPaths" field must contain an array.`);
+            }
+            else {
+                const pathList = configObj.extraPaths;
+                pathList.forEach((path, pathIndex) => {
+                    if (typeof path !== 'string') {
+                        console.error(`Config "extraPaths" field ${pathIndex} must be a string.`);
+                    }
+                    else {
+                        this.defaultExtraPaths.push((0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, path)));
+                    }
+                });
+            }
+        }
+        // Read the default "pythonVersion".
+        if (configObj.pythonVersion !== undefined) {
+            if (typeof configObj.pythonVersion === 'string') {
+                const version = (0, pythonVersion_1.versionFromString)(configObj.pythonVersion);
+                if (version) {
+                    this.defaultPythonVersion = version;
+                }
+                else {
+                    console.error(`Config "pythonVersion" field contains unsupported version.`);
+                }
+            }
+            else {
+                console.error(`Config "pythonVersion" field must contain a string.`);
+            }
+        }
+        this.ensureDefaultPythonVersion(host, console);
+        // Read the default "pythonPlatform".
+        if (configObj.pythonPlatform !== undefined) {
+            if (typeof configObj.pythonPlatform !== 'string') {
+                console.error(`Config "pythonPlatform" field must contain a string.`);
+            }
+            else {
+                this.defaultPythonPlatform = configObj.pythonPlatform;
+            }
+        }
+        this.ensureDefaultPythonPlatform(host, console);
+        // Read the "typeshedPath" setting.
+        this.typeshedPath = undefined;
+        if (configObj.typeshedPath !== undefined) {
+            if (typeof configObj.typeshedPath !== 'string') {
+                console.error(`Config "typeshedPath" field must contain a string.`);
+            }
+            else {
+                this.typeshedPath = configObj.typeshedPath
+                    ? (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, configObj.typeshedPath))
+                    : '';
+            }
+        }
+        // Read the "stubPath" setting.
+        this.stubPath = undefined;
+        // Keep this for backward compatibility
+        if (configObj.typingsPath !== undefined) {
+            if (typeof configObj.typingsPath !== 'string') {
+                console.error(`Config "typingsPath" field must contain a string.`);
+            }
+            else {
+                console.error(`Config "typingsPath" is now deprecated. Please, use stubPath instead.`);
+                this.stubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, configObj.typingsPath));
+            }
+        }
+        if (configObj.stubPath !== undefined) {
+            if (typeof configObj.stubPath !== 'string') {
+                console.error(`Config "stubPath" field must contain a string.`);
+            }
+            else {
+                this.stubPath = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, configObj.stubPath));
+            }
+        }
+        // Read the "verboseOutput" setting.
+        // Don't initialize to a default value because we want the command-line "verbose"
+        // switch to apply if this setting isn't specified in the config file.
+        if (configObj.verboseOutput !== undefined) {
+            if (typeof configObj.verboseOutput !== 'boolean') {
+                console.error(`Config "verboseOutput" field must be true or false.`);
+            }
+            else {
+                this.verboseOutput = configObj.verboseOutput;
+            }
+        }
+        // Read the "defineConstant" setting.
+        if (configObj.defineConstant !== undefined) {
+            if (typeof configObj.defineConstant !== 'object' || Array.isArray(configObj.defineConstant)) {
+                console.error(`Config "defineConstant" field must contain a map indexed by constant names.`);
+            }
+            else {
+                const keys = Object.getOwnPropertyNames(configObj.defineConstant);
+                keys.forEach((key) => {
+                    const value = configObj.defineConstant[key];
+                    const valueType = typeof value;
+                    if (valueType !== 'boolean' && valueType !== 'string') {
+                        console.error(`Defined constant "${key}" must be associated with a boolean or string value.`);
+                    }
+                    else {
+                        this.defineConstant.set(key, value);
+                    }
+                });
+            }
+        }
+        // Read the "useLibraryCodeForTypes" setting.
+        if (configObj.useLibraryCodeForTypes !== undefined) {
+            if (typeof configObj.useLibraryCodeForTypes !== 'boolean') {
+                console.error(`Config "useLibraryCodeForTypes" field must be true or false.`);
+            }
+            else {
+                this.useLibraryCodeForTypes = configObj.useLibraryCodeForTypes;
+            }
+        }
+        // Read the "executionEnvironments" array. This should be done at the end
+        // after we've established default values.
+        this.executionEnvironments = [];
+        if (configObj.executionEnvironments !== undefined) {
+            if (!Array.isArray(configObj.executionEnvironments)) {
+                console.error(`Config "executionEnvironments" field must contain an array.`);
+            }
+            else {
+                const execEnvironments = configObj.executionEnvironments;
+                execEnvironments.forEach((env, index) => {
+                    const execEnv = this._initExecutionEnvironmentFromJson(env, index, console);
+                    if (execEnv) {
+                        this.executionEnvironments.push(execEnv);
+                    }
+                });
+            }
+        }
+        // Read the "autoImportCompletions" setting.
+        if (configObj.autoImportCompletions !== undefined) {
+            if (typeof configObj.autoImportCompletions !== 'boolean') {
+                console.error(`Config "autoImportCompletions" field must be true or false.`);
+            }
+            else {
+                this.autoImportCompletions = configObj.autoImportCompletions;
+            }
+        }
+        // Read the "indexing" setting.
+        if (configObj.indexing !== undefined) {
+            if (typeof configObj.indexing !== 'boolean') {
+                console.error(`Config "indexing" field must be true or false.`);
+            }
+            else {
+                this.indexing = configObj.indexing;
+            }
+        }
+        // Read the "logTypeEvaluationTime" setting.
+        if (configObj.logTypeEvaluationTime !== undefined) {
+            if (typeof configObj.logTypeEvaluationTime !== 'boolean') {
+                console.error(`Config "logTypeEvaluationTime" field must be true or false.`);
+            }
+            else {
+                this.logTypeEvaluationTime = configObj.logTypeEvaluationTime;
+            }
+        }
+        // Read the "typeEvaluationTimeThreshold" setting.
+        if (configObj.typeEvaluationTimeThreshold !== undefined) {
+            if (typeof configObj.typeEvaluationTimeThreshold !== 'number') {
+                console.error(`Config "typeEvaluationTimeThreshold" field must be a number.`);
+            }
+            else {
+                this.typeEvaluationTimeThreshold = configObj.typeEvaluationTimeThreshold;
+            }
+        }
+    }
+    ensureDefaultPythonPlatform(host, console) {
+        // If no default python platform was specified, assume that the
+        // user wants to use the current platform.
+        if (this.defaultPythonPlatform !== undefined) {
+            return;
+        }
+        this.defaultPythonPlatform = host.getPythonPlatform();
+        if (this.defaultPythonPlatform !== undefined) {
+            console.info(`Assuming Python platform ${this.defaultPythonPlatform}`);
+        }
+    }
+    ensureDefaultPythonVersion(host, console) {
+        // If no default python version was specified, retrieve the version
+        // from the currently-selected python interpreter.
+        if (this.defaultPythonVersion !== undefined) {
+            return;
+        }
+        const importFailureInfo = [];
+        this.defaultPythonVersion = host.getPythonVersion(this.pythonPath, importFailureInfo);
+        if (this.defaultPythonVersion !== undefined) {
+            console.info(`Assuming Python version ${(0, pythonVersion_1.versionToString)(this.defaultPythonVersion)}`);
+        }
+        for (const log of importFailureInfo) {
+            console.info(log);
+        }
+    }
+    ensureDefaultExtraPaths(fs, autoSearchPaths, extraPaths) {
+        const paths = [];
+        if (autoSearchPaths) {
+            // Auto-detect the common scenario where the sources are under the src folder
+            const srcPath = (0, pathUtils_1.resolvePaths)(this.projectRoot, pathConsts.src);
+            if (fs.existsSync(srcPath) && !fs.existsSync((0, pathUtils_1.resolvePaths)(srcPath, '__init__.py'))) {
+                paths.push(srcPath);
+            }
+        }
+        if (extraPaths && extraPaths.length > 0) {
+            for (const p of extraPaths) {
+                const path = (0, pathUtils_1.resolvePaths)(this.projectRoot, p);
+                paths.push(path);
+                if ((0, pathUtils_1.isDirectory)(fs, path)) {
+                    (0, collectionUtils_1.appendArray)(paths, (0, pythonPathUtils_1.getPathsFromPthFiles)(fs, path));
+                }
+            }
+        }
+        if (paths.length > 0) {
+            this.defaultExtraPaths = paths;
+        }
+    }
+    applyDiagnosticOverrides(diagnosticSeverityOverrides) {
+        if (!diagnosticSeverityOverrides) {
+            return;
+        }
+        for (const ruleName of getDiagLevelDiagnosticRules()) {
+            const severity = diagnosticSeverityOverrides[ruleName];
+            if (severity !== undefined) {
+                this.diagnosticRuleSet[ruleName] = severity;
+            }
+        }
+    }
+    _convertBoolean(value, fieldName, defaultValue) {
+        if (value === undefined) {
+            return defaultValue;
+        }
+        else if (typeof value === 'boolean') {
+            return value ? true : false;
+        }
+        console.log(`Config "${fieldName}" entry must be true or false.`);
+        return defaultValue;
+    }
+    _convertDiagnosticLevel(value, fieldName, defaultValue) {
+        if (value === undefined) {
+            return defaultValue;
+        }
+        else if (typeof value === 'boolean') {
+            return value ? 'error' : 'none';
+        }
+        else if (typeof value === 'string') {
+            if (value === 'error' || value === 'warning' || value === 'information' || value === 'none') {
+                return value;
+            }
+        }
+        console.log(`Config "${fieldName}" entry must be true, false, "error", "warning", "information" or "none".`);
+        return defaultValue;
+    }
+    _initExecutionEnvironmentFromJson(envObj, index, console) {
+        try {
+            const newExecEnv = new ExecutionEnvironment(this.projectRoot, this.defaultPythonVersion, this.defaultPythonPlatform, this.defaultExtraPaths);
+            // Validate the root.
+            if (envObj.root && typeof envObj.root === 'string') {
+                newExecEnv.root = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, envObj.root));
+            }
+            else {
+                console.error(`Config executionEnvironments index ${index}: missing root value.`);
+            }
+            // Validate the extraPaths.
+            if (envObj.extraPaths) {
+                if (!Array.isArray(envObj.extraPaths)) {
+                    console.error(`Config executionEnvironments index ${index}: extraPaths field must contain an array.`);
+                }
+                else {
+                    const pathList = envObj.extraPaths;
+                    pathList.forEach((path, pathIndex) => {
+                        if (typeof path !== 'string') {
+                            console.error(`Config executionEnvironments index ${index}:` +
+                                ` extraPaths field ${pathIndex} must be a string.`);
+                        }
+                        else {
+                            newExecEnv.extraPaths.push((0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(this.projectRoot, path)));
+                        }
+                    });
+                }
+            }
+            // Validate the pythonVersion.
+            if (envObj.pythonVersion) {
+                if (typeof envObj.pythonVersion === 'string') {
+                    const version = (0, pythonVersion_1.versionFromString)(envObj.pythonVersion);
+                    if (version) {
+                        newExecEnv.pythonVersion = version;
+                    }
+                    else {
+                        console.warn(`Config executionEnvironments index ${index} contains unsupported pythonVersion.`);
+                    }
+                }
+                else {
+                    console.error(`Config executionEnvironments index ${index} pythonVersion must be a string.`);
+                }
+            }
+            // Validate the pythonPlatform.
+            if (envObj.pythonPlatform) {
+                if (typeof envObj.pythonPlatform === 'string') {
+                    newExecEnv.pythonPlatform = envObj.pythonPlatform;
+                }
+                else {
+                    console.error(`Config executionEnvironments index ${index} pythonPlatform must be a string.`);
+                }
+            }
+            return newExecEnv;
+        }
+        catch {
+            console.error(`Config executionEnvironments index ${index} is not accessible.`);
+        }
+        return undefined;
+    }
+}
+exports.ConfigOptions = ConfigOptions;
+//# sourceMappingURL=configOptions.js.map