// Convert deprecated typingOptions.enableAutoDiscovery to typeAcquisition.enable

if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) {

const result: TypeAcquisition = {

enable: typeAcquisition.enableAutoDiscovery,

include: typeAcquisition.include || [],

exclude: typeAcquisition.exclude || []

};

return result;

}

return typeAcquisition;

if (optionNameMapCache) {

return optionNameMapCache;

}

const optionNameMap = createMap<CommandLineOption>();

const shortOptionNames = createMap<string>();

forEach(optionDeclarations, option => {

optionNameMap[option.name.toLowerCase()] = option;

if (option.shortName) {

shortOptionNames[option.shortName] = option.name;

}

});

optionNameMapCache = { optionNameMap, shortOptionNames };

return optionNameMapCache;

value = trimString(value);

if (startsWith(value, "-")) {

return undefined;

}

if (value === "") {

return [];

}

const values = value.split(",");

switch (opt.element.type) {

case "number":

return map(values, parseInt);

case "string":

return map(values, v => v || "");

default:

return filter(map(values, v => parseCustomTypeOption(<CommandLineOptionOfCustomType>opt.element, v, errors)), v => !!v);

}

const options: CompilerOptions = {};

const fileNames: string[] = [];

const errors: Diagnostic[] = [];

const { optionNameMap, shortOptionNames } = getOptionNameMap();

parseStrings(commandLine);

return {

options,

fileNames,

errors

};

function parseStrings(args: string[]) {

let i = 0;

while (i < args.length) {

let s = args[i];

i++;

if (s.charCodeAt(0) === CharacterCodes.at) {

parseResponseFile(s.slice(1));

}

else if (s.charCodeAt(0) === CharacterCodes.minus) {

s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();

// Try to translate short option names to their full equivalents.

if (s in shortOptionNames) {

s = shortOptionNames[s];

}

if (s in optionNameMap) {

const opt = optionNameMap[s];

if (opt.isTSConfigOnly) {

errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));

}

else {

// Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).

if (!args[i] && opt.type !== "boolean") {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_expects_an_argument, opt.name));

}

switch (opt.type) {

case "number":

options[opt.name] = parseInt(args[i]);

i++;

break;

case "boolean":

// boolean flag has optional value true, false, others

const optValue = args[i];

options[opt.name] = optValue !== "false";

// consume next argument as boolean flag value

if (optValue === "false" || optValue === "true") {

i++;

}

break;

case "string":

options[opt.name] = args[i] || "";

i++;

break;

case "list":

const result = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);

options[opt.name] = result || [];

if (result) {

i++;

}

break;

// If not a primitive, the possible types are specified in what is effectively a map of options.

default:

options[opt.name] = parseCustomTypeOption(<CommandLineOptionOfCustomType>opt, args[i], errors);

i++;

break;

}

}

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Unknown_compiler_option_0, s));

}

}

else {

fileNames.push(s);

}

}

}

function parseResponseFile(fileName: string) {

const text = readFile ? readFile(fileName) : sys.readFile(fileName);

if (!text) {

errors.push(createCompilerDiagnostic(Diagnostics.File_0_not_found, fileName));

return;

}

const args: string[] = [];

let pos = 0;

while (true) {

while (pos < text.length && text.charCodeAt(pos) <= CharacterCodes.space) pos++;

if (pos >= text.length) break;

const start = pos;

if (text.charCodeAt(start) === CharacterCodes.doubleQuote) {

pos++;

while (pos < text.length && text.charCodeAt(pos) !== CharacterCodes.doubleQuote) pos++;

if (pos < text.length) {

args.push(text.substring(start + 1, pos));

pos++;

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));

}

}

else {

while (text.charCodeAt(pos) > CharacterCodes.space) pos++;

args.push(text.substring(start, pos));

}

}

parseStrings(args);

}

let text = "";

try {

text = readFile(fileName);

}

catch (e) {

return { error: createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message) };

}

return parseConfigFileTextToJson(fileName, text);

try {

const jsonTextToParse = stripComments ? removeComments(jsonText) : jsonText;

return { config: /\S/.test(jsonTextToParse) ? JSON.parse(jsonTextToParse) : {} };

}

catch (e) {

return { error: createCompilerDiagnostic(Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };

}

const compilerOptions = extend(options, defaultInitCompilerOptions);

const configurations: any = {

compilerOptions: serializeCompilerOptions(compilerOptions)

};

if (fileNames && fileNames.length) {

// only set the files property if we have at least one file

configurations.files = fileNames;

}

return configurations;

function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string | number> | undefined {

if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean") {

// this is of a type CommandLineOptionOfPrimitiveType

return undefined;

}

else if (optionDefinition.type === "list") {

return getCustomTypeMapOfCommandLineOption((<CommandLineOptionOfListType>optionDefinition).element);

}

else {

return (<CommandLineOptionOfCustomType>optionDefinition).type;

}

}

function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: MapLike<string | number>): string | undefined {

// There is a typeMap associated with this command-line option so use it to map value back to its name

for (const key in customTypeMap) {

if (customTypeMap[key] === value) {

return key;

}

}

return undefined;

}

function serializeCompilerOptions(options: CompilerOptions): Map<CompilerOptionsValue> {

const result = createMap<CompilerOptionsValue>();

const optionsNameMap = getOptionNameMap().optionNameMap;

for (const name in options) {

if (hasProperty(options, name)) {

// tsconfig only options cannot be specified via command line,

// so we can assume that only types that can appear here string | number | boolean

switch (name) {

case "init":

case "watch":

case "version":

case "help":

case "project":

break;

default:

const value = options[name];

const optionDefinition = optionsNameMap[name.toLowerCase()];

if (optionDefinition) {

const customTypeMap = getCustomTypeMapOfCommandLineOption(optionDefinition);

if (!customTypeMap) {

// There is no map associated with this compiler option then use the value as-is

// This is the case if the value is expect to be string, number, boolean or list of string

result[name] = value;

}

else {

if (optionDefinition.type === "list") {

const convertedValue: string[] = [];

for (const element of value as (string | number)[]) {

convertedValue.push(getNameOfCompilerOptionValue(element, customTypeMap));

}

result[name] = convertedValue;

}

else {

// There is a typeMap associated with this command-line option so use it to map value back to its name

result[name] = getNameOfCompilerOptionValue(value, customTypeMap);

}

}

}

break;

}

}

}

return result;

}

let output = "";

const scanner = createScanner(ScriptTarget.ES5, /* skipTrivia */ false, LanguageVariant.Standard, jsonText);

let token: SyntaxKind;

while ((token = scanner.scan()) !== SyntaxKind.EndOfFileToken) {

switch (token) {

case SyntaxKind.SingleLineCommentTrivia:

case SyntaxKind.MultiLineCommentTrivia:

// replace comments with whitespace to preserve original character positions

output += scanner.getTokenText().replace(/\S/g, " ");

break;

default:

output += scanner.getTokenText();

break;

}

}

return output;

const errors: Diagnostic[] = [];

basePath = normalizeSlashes(basePath);

const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames);

const resolvedPath = toPath(configFileName || "", basePath, getCanonicalFileName);

if (resolutionStack.indexOf(resolvedPath) >= 0) {

return {

options: {},

fileNames: [],

typeAcquisition: {},

raw: json,

errors: [createCompilerDiagnostic(Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, [...resolutionStack, resolvedPath].join(" -> "))],

wildcardDirectories: {}

};

}

let options: CompilerOptions = convertCompilerOptionsFromJsonWorker(json["compilerOptions"], basePath, errors, configFileName);

// typingOptions has been deprecated and is only supported for backward compatibility purposes.

// It should be removed in future releases - use typeAcquisition instead.

const jsonOptions = json["typeAcquisition"] || json["typingOptions"];

const typeAcquisition: TypeAcquisition = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName);

if (json["extends"]) {

let [include, exclude, files, baseOptions]: [string[], string[], string[], CompilerOptions] = [undefined, undefined, undefined, {}];

if (typeof json["extends"] === "string") {

[include, exclude, files, baseOptions] = (tryExtendsName(json["extends"]) || [include, exclude, files, baseOptions]);

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string"));

}

if (include && !json["include"]) {

json["include"] = include;

}

if (exclude && !json["exclude"]) {

json["exclude"] = exclude;

}

if (files && !json["files"]) {

json["files"] = files;

}

options = assign({}, baseOptions, options);

}

options = extend(existingOptions, options);

options.configFilePath = configFileName;

const { fileNames, wildcardDirectories } = getFileNames(errors);

const compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);

return {

options,

fileNames,

typeAcquisition,

raw: json,

errors,

wildcardDirectories,

compileOnSave

};

function tryExtendsName(extendedConfig: string): [string[], string[], string[], CompilerOptions] {

// If the path isn't a rooted or relative path, don't try to resolve it (we reserve the right to special case module-id like paths in the future)

if (!(isRootedDiskPath(extendedConfig) || startsWith(normalizeSlashes(extendedConfig), "./") || startsWith(normalizeSlashes(extendedConfig), "../"))) {

errors.push(createCompilerDiagnostic(Diagnostics.A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not, extendedConfig));

return;

}

let extendedConfigPath = toPath(extendedConfig, basePath, getCanonicalFileName);

if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json")) {

extendedConfigPath = `${extendedConfigPath}.json` as Path;

if (!host.fileExists(extendedConfigPath)) {

errors.push(createCompilerDiagnostic(Diagnostics.File_0_does_not_exist, extendedConfig));

return;

}

}

const extendedResult = readConfigFile(extendedConfigPath, path => host.readFile(path));

if (extendedResult.error) {

errors.push(extendedResult.error);

return;

}

const extendedDirname = getDirectoryPath(extendedConfigPath);

const relativeDifference = convertToRelativePath(extendedDirname, basePath, getCanonicalFileName);

const updatePath: (path: string) => string = path => isRootedDiskPath(path) ? path : combinePaths(relativeDifference, path);

// Merge configs (copy the resolution stack so it is never reused between branches in potential diamond-problem scenarios)

const result = parseJsonConfigFileContent(extendedResult.config, host, extendedDirname, /*existingOptions*/undefined, getBaseFileName(extendedConfigPath), resolutionStack.concat([resolvedPath]));

errors.push(...result.errors);

const [include, exclude, files] = map(["include", "exclude", "files"], key => {

if (!json[key] && extendedResult.config[key]) {

return map(extendedResult.config[key], updatePath);

}

});

return [include, exclude, files, result.options];

}